{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 21点游戏的蒙特卡洛学习"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 示例：二十一点游戏 Blackjack Example\n",
    "该示例解释了Model-Free下的策略评估问题和结果，没有说具体的学习过程。\n",
    "\n",
    "状态空间：（多达200种，根据对状态的定义可以有不同的状态空间，这里采用的定义是牌的分数，不包括牌型）由三个维度构成：\n",
    "\n",
    "当前牌的分数（12 - 21），低于12时，你可以安全的再叫牌，所以没意义。\n",
    "\n",
    "庄家出示的牌（A - 10），庄家会显示一张牌面给玩家\n",
    "\n",
    "我有“useable” ace吗？（是或否）A既可以当1点也可以当11点。\n",
    "\n",
    "行为空间：\n",
    "\n",
    "  停止要牌 stick\n",
    "  \n",
    "  继续要牌 twist\n",
    "  \n",
    "奖励（停止要牌）：\n",
    "\n",
    "+1：如果你的牌分数大于庄家分数\n",
    "\n",
    "0： 如果两者分数相同\n",
    "\n",
    "-1：如果你的牌分数小于庄家分数\n",
    "\n",
    "\n",
    "奖励（继续要牌）：\n",
    "\n",
    "-1：如果牌的分数>21，并且进入终止状态\n",
    "\n",
    "0：其它情况\n",
    "\n",
    "\n",
    "状态转换（Transitions）：如果牌分小于12时，自动要牌\n",
    "\n",
    "当前策略：牌分只要小于20就继续要牌。\n",
    "\n",
    "求解问题：评估该策略的好坏。\n",
    "\n",
    "\n",
    "求解过程：使用庄家显示的牌面值、玩家当前牌面总分值来确定一个二维状态空间，区分手中有无A分别处理。统计每一牌局下决定状态的庄家和玩家牌面的状态数据，同时计算其最终收获。通过模拟多次牌局，计算每一个状态下的平均值，得到如下图示。\n",
    "最终结果：无论玩家手中是否有A牌，该策略在绝大多数情况下各状态价值都较低，只有在玩家拿到21分时状态价值有一个明显的提升。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 蒙特卡罗预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import shuffle\n",
    "from queue import Queue\n",
    "from tqdm import tqdm\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from utils import str_key, set_dict, get_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [\"继续叫牌\",\"停止叫牌\"]  \n",
    "#A = [0,1]  \n",
    "def value_of(card):\n",
    "    '''根据牌的字符判断牌的数值大小，A被输出为1, JQK均为10，其余按牌字符对应的数字取值\n",
    "    Args:\n",
    "        card: 牌面信息 str\n",
    "    Return:\n",
    "        牌的大小数值 int, A 返回 1\n",
    "    '''\n",
    "    try:\n",
    "        v = int(card)\n",
    "    except:\n",
    "        if card == 'A':\n",
    "            v = 1\n",
    "        elif card in ['J','Q','K']:\n",
    "            v = 10\n",
    "        else:\n",
    "            v = 0\n",
    "    finally:\n",
    "        return v\n",
    "\n",
    "def points_of(cards):\n",
    "    '''统计一手牌分值，如果使用了A的1点，同时返回True\n",
    "    Args:\n",
    "        cards 庄家或玩家手中的牌 list ['A','10','3']\n",
    "    Return\n",
    "        tuple (返回牌总点数,是否使用了可复用Ace) \n",
    "        例如['A','10','3'] 返回 (14, True)\n",
    "           ['A','10'] 返回 （21, False)\n",
    "    '''\n",
    "    num_of_useable_ace = 0 # 默认没有拿到Ace\n",
    "    total_point = 0 # 总值\n",
    "    if cards is None:\n",
    "        return 0, False\n",
    "    for card in cards:\n",
    "        v = value_of(card)\n",
    "        if v == 1:\n",
    "            num_of_useable_ace += 1\n",
    "            v = 11\n",
    "        total_point += v\n",
    "    while total_point > 21 and num_of_useable_ace > 0:\n",
    "        total_point -= 10\n",
    "        num_of_useable_ace -= 1\n",
    "    return total_point, bool(num_of_useable_ace)\n",
    "    \n",
    "def get_state(dealer, player):\n",
    "    '''显示完整的状态，包括庄家的总分、玩家的总分、玩家是否有useable_ace\n",
    "    '''\n",
    "    player_points, useable_ace = points_of(player.cards)\n",
    "    #dealer = list(dealer) # 考虑到dealer只传第一张牌字符串的情况\n",
    "    dealer_points, _ = points_of(dealer.cards)\n",
    "    return dealer_points, player_points, int(useable_ace)\n",
    "\n",
    "def get_state_name(dealer, player):\n",
    "    '''只获得庄家的第一张牌信息和总点数信息，以及有无useable_ace，形成字符串作为字典键\n",
    "    '''\n",
    "    player_points, useable_ace = points_of(player.cards)\n",
    "    first_dealer_card = 0\n",
    "    if dealer.cards is None or len(dealer.cards) == 0:\n",
    "        pass\n",
    "    else:\n",
    "        first_dealer_card = value_of(dealer.cards[0])\n",
    "    return str(first_dealer_card) + \"_\" + str(player_points) + \"_\" + str(int(useable_ace))\n",
    "\n",
    "\n",
    "def reward_of(dealer, player):\n",
    "    '''判断玩家奖励值，附带玩家、庄家的牌点信息\n",
    "    '''\n",
    "    dealer_points, _ = points_of(dealer.cards)\n",
    "    player_points, useable_ace = points_of(player.cards)\n",
    "    if player_points > 21:\n",
    "        reward = -1\n",
    "    else:\n",
    "        if player_points > dealer_points or dealer_points > 21:\n",
    "            reward = 1\n",
    "        elif player_points == dealer_points:\n",
    "            reward = 0\n",
    "        else:\n",
    "            reward = -1\n",
    "    return reward, player_points, dealer_points, useable_ace\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 辅助函数：读取字典\n",
    "def str_key(*args):\n",
    "    '''将参数用\"_\"连接起来作为字典的键，需注意参数本身不是基本数据类型，而是tuple或者list型，\n",
    "    比如类似((a,b,c),d)的形式。\n",
    "    '''\n",
    "    new_arg = []\n",
    "    for arg in args:\n",
    "        if type(arg) in [tuple, list]:\n",
    "            new_arg += [str(i) for i in arg]\n",
    "        else:\n",
    "            new_arg.append(str(arg))\n",
    "    return \"_\".join(new_arg)\n",
    "\n",
    "def set_dict(target_dict, value, *args):\n",
    "    target_dict[str_key(*args)] = value\n",
    "\n",
    "def get_dict(target_dict, *args):\n",
    "    #print(\"key: {}\".format(str_key(*args)))\n",
    "    return target_dict.get(str_key(*args),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10_20_0_0\n",
      "10_20_0_1\n",
      "10_20_0_1\n",
      "0_20_0_1\n",
      "0_20_0_1\n"
     ]
    }
   ],
   "source": [
    "print(str_key(10,20,(0,0)))\n",
    "print(str_key((10,20),(0,1)))\n",
    "print(str_key(10,20,0,1))\n",
    "print(str_key(0,20,0,1))\n",
    "print(str_key((0,20,0,1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person():\n",
    "    def __init__(self, name=\"\"):\n",
    "        self.name = name\n",
    "    \n",
    "    def __str__(self):\n",
    "        return self.name\n",
    "\n",
    "class Player(Person):\n",
    "    def __init__(self, policy = None, name=\"\", role = \"\", display = False, A = A):\n",
    "        super(Player, self).__init__(name)\n",
    "        self.cards = [] # 玩家手中的牌\n",
    "        self.policy = policy # 策略\n",
    "        self.Q = {}   # 某一状态行为对的价值\n",
    "        self.Nsa = {} # Nsa的计数：某一状态行为对出现的次数\n",
    "        self.role = role # “庄家”还是“玩家”，庄家是特殊的玩家\n",
    "        self.A = A #行为空间\n",
    "        self.display = display # 是否使用print输出信息了解战局或计算情况\n",
    "        self.total_learning_times = 0\n",
    "     \n",
    "    def receive(self, cards = []): # 玩家获得一张或多张牌\n",
    "        cards = list(cards)\n",
    "        for card in cards:\n",
    "            self.cards.append(card)\n",
    "    \n",
    "    def discharge_cards(self): # 玩家把手中的牌清空，扔牌\n",
    "        '''扔牌\n",
    "        '''\n",
    "        self.cards.clear()\n",
    "    \n",
    "    def cards_info(self): # 玩家手中牌的信息\n",
    "        '''\n",
    "        显示牌面具体信息\n",
    "        '''\n",
    "        self._info(\"{}{}现在的牌:{}\\n\".format(self.role, self,self.cards))\n",
    "    \n",
    "    def _info(self, msg):\n",
    "        if self.display:\n",
    "            print(msg, end=\"\")\n",
    "            \n",
    "    def learn_Q(self, episode, r): # 从状态序列来学习Q值\n",
    "        '''从Episode学习\n",
    "        '''\n",
    "        #for episode, r in episodes:\n",
    "        for s, a in episode:\n",
    "            nsa = get_dict(self.Nsa, s, a)\n",
    "            set_dict(self.Nsa, nsa+1, s, a)\n",
    "            q = get_dict(self.Q, s,a)\n",
    "            set_dict(self.Q, q+(r-q)/(nsa+1), s, a)\n",
    "        self.total_learning_times += 1\n",
    "    \n",
    "    def reset_memory(self):\n",
    "        '''忘记既往学习经历\n",
    "        '''\n",
    "        self.Q.clear()\n",
    "        self.Nsa.clear()\n",
    "        self.total_learning_times = 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Arena():\n",
    "    '''负责游戏管理\n",
    "    '''\n",
    "    def __init__(self, display = None, A = A):\n",
    "        self.cards = ['A','2','3','4','5','6','7','8','9','10','J','Q',\"K\"]*4\n",
    "        self.card_q = Queue(maxsize = 52) # 洗好的牌\n",
    "        self.cards_in_pool = [] # 已经用过的公开的牌  \n",
    "        self.display = display\n",
    "        self.episodes = [] # 产生的对局信息列表\n",
    "        self.load_cards(self.cards)# 把初始状态的52张牌装入发牌器\n",
    "        self.A = A # 获得行为空间\n",
    "        \n",
    "    def play_game(self, dealer, player):\n",
    "        '''玩一局21点，生成一个状态序列以及最终奖励（中间奖励为0）\n",
    "        Args：\n",
    "            dealer/player 庄家和玩家手中的牌 list\n",
    "        Returns:\n",
    "            tuple：episode, reward\n",
    "        '''\n",
    "        #self.collect_player_cards()\n",
    "        self._info(\"========= 开始新一局 =========\\n\")\n",
    "        self.serve_card_to(player, n=2) # 发两张牌给玩家\n",
    "        self.serve_card_to(dealer, n=2) # 发两张牌给庄家\n",
    "        episode = [] # 记录一个对局信息\n",
    "        if player.policy is None:\n",
    "            self._info(\"玩家需要一个策略\")\n",
    "            return\n",
    "        if dealer.policy is None:\n",
    "            self._info(\"庄家需要一个策略\")\n",
    "            return\n",
    "        while True:\n",
    "            s = get_state(dealer = dealer, player = player) # 获取状态信息\n",
    "            #epsilon = 1.0/(1 + math.sqrt(1 + player.total_learning_times))\n",
    "            epsilon = 1.0/(1 + 10 * math.log10(1+player.total_learning_times))\n",
    "            action = player.policy(player.A, s, player.Q, epsilon)\n",
    "            # 玩家的策略产生一个行为\n",
    "            self._info(\"{}{}选择:{};\".format(player.role, player, action))\n",
    "            if action == self.A[0]: # 继续叫牌\n",
    "                episode.append((get_state_name(dealer, player), action)) # 记录一个(s,a)\n",
    "                self.serve_card_to(player) # 发一张牌给玩家\n",
    "            else: # 停止叫牌\n",
    "                episode.append((get_state_name(dealer, player), self.A[1])) # 记录一个(s,a)\n",
    "                break\n",
    "        # 玩家停止叫牌后要计算下玩家手中的点数，玩家如果爆了，庄家就不用继续了        \n",
    "        reward, player_points, dealer_points, useable_ace = reward_of(dealer, player)\n",
    "        \n",
    "        if player_points > 21:\n",
    "            self._info(\"玩家爆点{}输了，得分:{}\\n\".format(player_points, reward))\n",
    "            self.recycle_cards(player, dealer)\n",
    "            self.episodes.append((episode, reward)) # 预测的时候需要形成episode list后同一学习V\n",
    "            # 在蒙特卡洛控制的时候，可以不需要episodes list,生成一个episode学习一个，下同\n",
    "            self._info(\"========= 本局结束 ==========\\n\")\n",
    "            return episode, reward\n",
    "        # 玩家并没有超过21点\n",
    "        self._info(\"\\n\")\n",
    "        while True:\n",
    "            s = get_state(dealer = dealer, player = player) # 获取状态信息\n",
    "            action = dealer.policy(self.A, s, None, None) # 庄家从其策略中获取一个行为\n",
    "            self._info(\"{}{}选择:{};\".format(dealer.role, dealer, action))\n",
    "            if action == self.A[0]: # 庄家\"继续要牌\":\n",
    "                self.serve_card_to(dealer)\n",
    "                # 停止要牌是针对玩家来说的，episode不记录庄家动作\n",
    "                # 在状态只记录庄家第一章牌信息时，可不重复记录(s,a)，因为此时玩家不再叫牌，(s,a)均相同\n",
    "                # episode.append((get_state_name(dealer, player), self.A[1]))\n",
    "            else:\n",
    "                break\n",
    "        # 双方均停止叫牌了    \n",
    "        self._info(\"\\n双方均了停止叫牌;\\n\")\n",
    "        reward, player_points, dealer_points, useable_ace = reward_of(dealer, player)\n",
    "        player.cards_info() \n",
    "        dealer.cards_info()\n",
    "        if reward == +1:\n",
    "            self._info(\"玩家赢了!\")\n",
    "        elif reward == -1:\n",
    "            self._info(\"玩家输了!\")\n",
    "        else:\n",
    "            self._info(\"双方和局!\")\n",
    "        self._info(\"玩家{}点,庄家{}点\\n\".format(player_points, dealer_points))\n",
    "        \n",
    "        self._info(\"========= 本局结束 ==========\\n\")\n",
    "        self.recycle_cards(player, dealer) # 回收玩家和庄家手中的牌至公开牌池\n",
    "        self.episodes.append((episode, reward)) # 将刚才产生的完整对局添加值状态序列列表，蒙特卡洛控制不需要\n",
    "        return episode, reward\n",
    "    \n",
    "    def play_games(self, dealer, player, num=2, show_statistic = False):\n",
    "        '''一次性玩多局游戏\n",
    "        '''\n",
    "        results = [0, 0, 0]# 玩家负、和、胜局数\n",
    "        self.episodes.clear()\n",
    "        for i in tqdm(range(num)):\n",
    "            episode, reward = self.play_game(dealer, player)\n",
    "            results[1+reward] += 1\n",
    "            player.learn_Q(episode ,reward)\n",
    "        if show_statistic:\n",
    "            print(\"共玩了{}局，玩家赢{}局，和{}局，输{}局，胜率：{:.2f}\"\\\n",
    "              .format(num, results[2],results[1],results[0],results[2]/num))\n",
    "        pass\n",
    "        \n",
    "    def load_cards(self, cards):\n",
    "        '''把收集的牌洗一洗，重新装到发牌器中\n",
    "        Args:\n",
    "            cards 要装入发牌器的多张牌 list\n",
    "        Return:\n",
    "            None\n",
    "        '''\n",
    "        shuffle(cards) # 洗牌\n",
    "        for card in cards:# deque数据结构只能一个一个添加\n",
    "            self.card_q.put(card)\n",
    "        cards.clear() # 原来的牌清空\n",
    "        return\n",
    "    \n",
    "    \n",
    "    def serve_card_to(self, player, n = 1):\n",
    "        '''给庄家或玩家发牌，如果牌不够则将公开牌池的牌洗一洗重新发牌\n",
    "        Args:\n",
    "            player 一个庄家或玩家 \n",
    "            n 一次连续发牌的数量\n",
    "        Return:\n",
    "            None\n",
    "        '''\n",
    "        cards = []  #将要发出的牌\n",
    "        for _ in range(n):\n",
    "            # 要考虑发牌器没有牌的情况\n",
    "            if self.card_q.empty():\n",
    "                self._info(\"\\n发牌器没牌了，整理废牌，重新洗牌;\")\n",
    "                shuffle(self.cards_in_pool)\n",
    "                self._info(\"一共整理了{}张已用牌，重新放入发牌器\\n\".format(len(self.cards_in_pool)))\n",
    "                assert(len(self.cards_in_pool) > 20) # 确保有足够的牌，将该数值设置成40左右时，如果玩家\n",
    "                # 即使爆点了也持续的叫牌，会导致玩家手中牌变多而发牌器和已使用的牌都很少，需避免这种情况。\n",
    "                self.load_cards(self.cards_in_pool) # 将收集来的用过的牌洗好送入发牌器重新使用\n",
    "            cards.append(self.card_q.get()) # 从发牌器发出一章牌\n",
    "        self._info(\"发了{}张牌({})给{}{};\".format(n, cards, player.role, player))\n",
    "        #self._info(msg)\n",
    "        player.receive(cards) # 牌已发给某一玩家\n",
    "        player.cards_info()\n",
    "\n",
    "    def recycle_cards(self, *players):\n",
    "        '''回收玩家手中的牌到公开使用过的牌池中\n",
    "        '''\n",
    "        if len(players) == 0:\n",
    "            return\n",
    "        for player in players:\n",
    "            for card in player.cards:\n",
    "                self.cards_in_pool.append(card)\n",
    "            player.discharge_cards() # 玩家手中不再留有这些牌\n",
    "            \n",
    "    def _info(self, message):\n",
    "        if self.display:\n",
    "            print(message, end=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def policy_for_dealer(A, s, Q = None, k = None):\n",
    "    '''庄家策略,不同的策略需要的参数不一样，这是玩家所能参考的最多的信息\n",
    "    Args:\n",
    "        A 行为空间 list []\n",
    "        s 状态空间 s = (dealer_points, player_points, useable_ace) tuple\n",
    "        Q 行为价值字典 {}\n",
    "        k 对局的次数，用于计算epsilon-greedy算法中的epsilon\n",
    "    '''\n",
    "    dealer_points, player_points, useable_ace = s\n",
    "    action = \"\"\n",
    "    if dealer_points >= 17:#or player_points > 21:\n",
    "        action = A[1] # \"停止要牌\"\n",
    "    else:\n",
    "        action = A[0]\n",
    "    #elif dealer_points < player_points:\n",
    "    #    action = A[0] # \"继续要牌\"\n",
    "    #else:\n",
    "    #    action = A[1] # \"停止要牌\"\n",
    "    return action\n",
    "\n",
    "\n",
    "def naive_policy(A, s, Q = None, k = None):\n",
    "    '''原始策略，玩家只要手中的牌值低于20就会持续叫牌\n",
    "    '''\n",
    "    _, player_points, _ = s\n",
    "    action = \"\"\n",
    "    if player_points < 20:\n",
    "        action = A[0]\n",
    "    else:\n",
    "        action = A[1]        \n",
    "    return action  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "display = False\n",
    "# 创建一个玩家一个庄家，玩家使用原始策略，庄家使用其固定的策略\n",
    "player = Player(policy = naive_policy, role=\"玩家\", display = display)\n",
    "dealer = Player(policy = policy_for_dealer, role = \"庄家\", display = display)\n",
    "# 创建一个场景\n",
    "arena = Arena(display=display)\n",
    "# 生成num个完整的对局"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20000/20000 [00:02<00:00, 8617.55it/s]\n"
     ]
    }
   ],
   "source": [
    "arena.play_games(dealer, player, num=20000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 统计个状态的价值，衰减因子为1，中间状态的即时奖励为0，递增式蒙特卡洛评估\n",
    "def learn_V(episodes, V, Ns):\n",
    "    for episode, r in episodes:\n",
    "        for s, a in episode:\n",
    "            ns = get_dict(Ns, s)\n",
    "            v = get_dict(V, s)\n",
    "            set_dict(Ns, ns+1, s)\n",
    "            set_dict(V, v+(r-v)/(ns+1), s)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "V = {} # 状态价值字典\n",
    "Ns = {} # 状态被访问的次数节点\n",
    "learn_V(arena.episodes, V, Ns) # 学习V值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_value(value_dict, useable_ace = 0, is_q_dict = False, A = None):\n",
    "    # 定义figure\n",
    "    fig = plt.figure()\n",
    "    # 将figure变为3d\n",
    "    ax = Axes3D(fig)\n",
    "    # 定义x, y\n",
    "    x = np.arange(1, 11, 1) # 庄家第一张牌\n",
    "    y = np.arange(12, 22, 1) # 玩家总分数\n",
    "    # 生成网格数据\n",
    "    X, Y = np.meshgrid(x, y)\n",
    "    # 从V字典检索Z轴的高度\n",
    "    row, col = X.shape\n",
    "    Z = np.zeros((row,col))\n",
    "    if is_q_dict:\n",
    "        n = len(A)\n",
    "    for i in range(row):\n",
    "        for j in range(col):\n",
    "            state_name = str(X[i,j])+\"_\"+str(Y[i,j])+\"_\"+str(useable_ace)\n",
    "            if not is_q_dict:\n",
    "                Z[i,j] = get_dict(value_dict, state_name)\n",
    "            else:\n",
    "                assert(A is not None)\n",
    "                for a in A:\n",
    "                    new_state_name = state_name + \"_\" + str(a)\n",
    "                    q = get_dict(value_dict, new_state_name)\n",
    "                    if q >= Z[i,j]:\n",
    "                        Z[i,j] = q\n",
    "    # 绘制3D曲面\n",
    "    ax.plot_surface(X, Y, Z, rstride = 1, cstride = 1, cmap = plt.cm.cool)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcUAAAE1CAYAAACWU/udAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvFvnyVgAAIABJREFUeJzsvWl0XGl57/vbQ80qyZYseZDbkq3BY9vtbrvbpqFpIBeSJpck93YgWTcMmeACH5KVrBxyVm7O5eQCISFpDiecm0MSciCHkIYk96TJOkBIQyCkabd7ngxtqTRYoy3JpZqnvfd7P8i7XJJq3PVut9vav7W8bEulvatKtd//fp73eZ6/IoTAw8PDw8PDA9RX+wl4eHh4eHjcLHii6OHh4eHhcQ1PFD08PDw8PK7hiaKHh4eHh8c1PFH08PDw8PC4hieKHh4eHh4e1/BE0cPDw8PD4xqeKHp4eHh4eFzDE0UPDw8PD49r6C0+3ht/4+Hh4eHxWkRp5kFepOjh4eHh4XENTxQ9PDw8PDyu4Ymih4eHh4fHNTxR9PDw8PDwuIYnih4eHh4eHtfwRNHDw8PDw+Manih6eHh4eHhcwxNFDw8PDw+Pa3ii6OHh4eHhcQ1PFD08PDw8PK7hiaKHh4eHh8c1PFH08PDw8PC4hieKHh4eHh4e1/BE0cPDw8PD4xqeKHp4eHh4eFzDE0UPDw8PD49reKLo4eHh4eFxDf3VfgIeHjcSIQSmaaIoCqqqoihNmXF7eHhsETxR9NgS2GJoGAaFQgEhBACqqqKqKrquo2la+f+eWHp4bE0Ue3FokpYe7OHxalMphkIIFEWhVCpR+bkXQrDxOlBVFU3Tyn88sfTweM3T1MXriaLHLUk1MbQFrVgslr9W62ftvz2x9PC4ZfBE0WPrIYTAMAxM09wkhjaNRLHese2/PbH08HjN4Ymix9bBFkPDMACqiqGNU1Gsd277b08sPTxuWjxR9Lj1aUUMbUqlEpZluS5MlWJZeb5CoUCxWKS7u9sTSw+PG0dTF5dXferxmsSJGN5o7Odjt3/Y5PN5lpeXiUajFIvFdc/biyw9PF5dPFH0eE1hWVa5gAZuTjFshP2cNU1b93U7/VoqlaqKpa7rZdH0xNLDwx08UfR4TXAriGEjar0mWyyr7YVujCo1Tbsl3xsPjxuFJ4oeNzWWZbG6ugpAKBS6ZRb8Vvby64mlfbNQTyxtwbxV3jsPDzfxRNHjpsSyrHJrxeXLlwkGg0QikVf7aUlBljB5YunhIR9PFD1uGir31CzLAq4XqbRYJb2laUYsN+KJpYfHGp4oerzq1BJDe0FWVbX8dQ/nNCuW6XSaTCbDzp07yyJpF/l4Yulxq+OJoserhr0YG4ZRVQxtZIpiNptlcnISIQQdHR10dHQQDofR9a17KWx8zw3DIJfLld930zQpFovrHm8X9Xhi6XGrsXVXAo9XjY1iaC+mtRZURVHaFsVsNsvExATpdJp9+/ahqiqZTIb5+XkymQymaRIIBOjo6CASiRCJRAiHw5vaJmSgKMpNnQ6uHI/XKLL0xNLjVsMTRY8bRqtiaNPOnmImk2FiYoJsNsuBAwc4evQopmlimibd3d3rnluhUCCTyZDJZLh69SrZbBbLsgiFQkQikbJghkKhdc34txqNRuA5Fctq9lyeWHrcbHii6OE6tRwrml0QnUSKmUyGWCxGLpfjwIED7Nixo+FCHwwGCQaD9PT0rHvuuVyuLJZLS0tks1kAwuFwOaq0xXIrL/KNxLJQKGx6fLXpPbfyDYfHzY8nih6uUU0MnSx4rewpptNpYrEY+XyeoaEhenp6ai7UzQiYoiiEw2HC4TC9vb3lr1uWVRbLVCrF4uJieR8uHA6vS8MGAoGmxVKYQAkw7D8KGCB0gbqjqUO0jcxh6VBdLO3Iv3IgQ+Xjaw0l8PBwG08UPaQjSwxtmkmf2mJYKBQYGhqiu7vb1UVUVdWy6PX19ZW/bpommXQW8zMB/OcClIqCUkmgmAqapaFaGkFzJwOlPkz0NdGrFEFRY1/1oIlVVOCNBsobDThrooTdeW2yRbEalXNhN54b6otl5X6lJ5YesvFE0UMassXQpl76NJVKEYvFKJVKZTF8NVHRyPzlDvr+2gc5SYv1kAk/ulbwM+FH/Dc/+AXitInyRhPeaMBhC1nacCNEsRbNiuXk5CR9fX2Ew+F1xT3eXFiPdvFE0aNtqhn7ytwXqpY+TaVSjI+PYxgGw8PDbN++Xdr5nCJMuPRQkJ4XFXmCCFhRA40NVbBFBR7TEY/p8IkA9FmIN5hrUeR9JkrPzVvd6oSNYlksFsvpVWDTzZj9WE8sPVrFE0UPx9hiODk5yW233SZdDG0q06fJZJLx8XEsy2JoaOimEEO4Loi58xqh5+UtumangfqSr/EDr6jw9yri732gCMQxC+4z1iLJUyZKE4eweTUjxWaprF6GxpFl5Wvy7Lk86uGJokfLbPQynJ+fL4uiGyiKQj6f55lnnkEIwdDQENu2bWvreDIR1pogrv6Lj+EdBuTlXVb6EeDxFm80hAIvavCihvgvQIdAnDXKqVZlsH4U+VoRxXo3YI3E0jAMSqXSuu95YukBnih6tEAtY187velGlLi6usorr7xCLpfj5MmTdHV1ST9HOwgLZv54TRADEYvg4xKb/TUBMQnvaVqBf/Yh/nktXBQDFvxMEWVAwEkTDghp+5E3CiGEo8+bJ5YejfBE0aMhjVzu3ZhNGo/HicViqKrK4OAgCwsLN6cgPhQk/i9rYnNb0IKCvEtKOW7CM/IvUWtOYH1RRY/7ARCdFsoJC+4wUU6aKLtUlO6be0/STp/KwhNLDxtPFD1q0qyxr6Zp0kTRFkNN0xgdHaWzs5NcLsf8/LyU48uiLIjfWRPEUIfkKBEg61I6+qSF/qT/+v+TKnxfhe/rCGAnI5R2FjHuEmgnBZy04LiJEnLl6TjCrczERjyx3Hp4ouixiUovQ2jscq+qalU7ola4evUqsVgMn8/HwYMHiUaj5e/JmH0qE2HBzKevCyJAv9+CosTLqbINQya6QJlpfFzfZT98HcTX1/4vVIFxoIC4w0C/S0G7CzhoobxKw2de7X3PRmJZKpVYXl4mHo8zODgIeGL5WsETRY8yrYqhjdP0qRCiLIZ+v59Dhw6tE8N2j+8GwoKZ/xQk/u3rghiKWgTPyRUwZbtL6cuTJjzZ+mWvWAq+8SCMA38HAjBDBsWRHNbxEuo9EDyuo+5Xbsj+pNM9RbexrxdN08oCaf/btkcrFoubth88sbx58ERxi9PIy7AZWhUtIQQrKytMTEwQCAQ4cuQIHR0ddY8v01Uim82SyWSIRqP4fM33KpQF8dH1P7NXlxwlbrfgeReiRFXAvDwh0XI6oRei8AJkn0+ivtCJGTQoDGYxRkooRyz02xWCd/hQt918AuY2lSneenNh64llZY+lPb3HE0t38URxiyJDDG2a3VO0xTAWixEKhTh69CiRSKThz8lKn9pDwrPZLJFIhKmpKQzDwO/3r3PBiEQimyyjagliKGoRkB0ljlpwzoVL804TnnLhuD0WkYtrEb6W1wn/qBN+BPzj9Yfke/MUD2QxR0uoR8F/XCN4xI+i37oLvGmaDa3HGollsVjclCquNRfWE0s5eKK4xZAphjaNIkUhBMvLy0xMTBAOhzl27FhTYtjs8RuRzWbLYnjgwAG6u7splUrlCLRYLJLJZEin08zNzZHJZNZZRkXCHWT++25S/7I5qtyrWVCSeBlpAiZciKoUsdbg7wLKcGMRDywFCSwF4YnrX7P8Jrm9WUrDecRBA+0oBE76COzxN/d5tIAMay0naQXSoNj/rvi6kr72bwR6QcHaZyH2CcSAhTVogfOW17o0I4q1aMaeq55Y2oLpiWXreKK4RXDqZdgMtQpthBAsLS0xMTFBR0cHt99+O+Fw61OsnT7HSmPhoaGhsn1UpcAqikIgECAQCGzyV8zlcqRTGZY/t43Suc3POxgt4Zcc0bnVhsFJl47bZ8EzzhZ+tagRmYjCRBS+df3rpW0FcoMZxL4iwXQIX8GHnvehZtWy+N2dvA+1oKHUGKBeDe1OA/3xze+B6BRrQjmwJpbWwNq/rYE14aT5+7d1WJaFrkv+fHhi6TqeKN7iuCmGNhsjOSEEV65cYWJigmg0yvHjxx2JoVNyuRyxWIx0Ol02Fm719SqKQigUZvlz3ZTOVd937C0WUIwW5qc1gyttGAJWXWrvGLDgstxlxLcawIeG7+9rH1ejxah3wER7orp4K0kF7SUNXqr+fdFzTSD3WdcEs+Lf+wQEqp/SNE0CgRrflEwzYrkRWyQrXUc8sfRE8ZbFdqy4fPly2UbJrQ+8vacohODy5ctMTk7S2dnJHXfcQSh045rbcrkcExMTJJNJhoaGHImhjRAw+5kA8X+uLnqRbRZd5xyGELVwqw3jDhOec+FS3+08SqyLX6DPyU316pG1ClonKCsq2gpVX6t5r4EaVzDvMzHeaGDea0Ln2vcsy3KcPpVFM2KZSqWYnZ1laGgI8MTSE8VbjI32TRcvXuR1r3udq+dUFIV4PM709DRdXV2cPHmSYDDo6jkryefzxGIxkskkBw4c4MiRI21dwLYgXv2Wv+Zj+i0LDMmpMbfaMDIuRYn9FszLX0LUEybKD+QdtzCcJfCs/EyFdcBEP6+hFNYiTf//60doAusOC+ONBuGhMNqPvbqiWItKkbPXC7t1xBbLYrG47vGVFl23slh6oniL4JaXYaNzLi4uMjU1RTAYfFXEcGJigkQiIUUM4Zog/uf6gtixzcIveXpNqaOI/pzealKwMbeba8PBZXOb6U6UuN1CfUHecQWCoMQB7eXj+gQKoBTWf94UU0F7WkN7WmOEEURAYJ4yMe8zMd9oYp42QXLGvV1M0yzvfTYTWdpiOTMzw2c/+1k+97nP3dDn6zaeKL7GaUYMZY/EEkKwsLDA1NQU27dvZ3BwEMuybpgg2mK4urrKgQMHOHz4sJS71bIg/lNtQQTYY1pgyr10/EdVOOfCTUyp8UOcoPQKuCQ/QlCHLJQqxTCOj3enif/x+r9PJ4jTJvq/NX6eSkFBf0xHf0yH3wcREZhn1gTSuM/AusNC/p1QaxiG0bAgqJpYrq6uksvl3HxqrwqeKL5GadbY197vkyGKlmWxsLDA9PQ03d3d3HXXXQQCAS5fvkw6nW77+I0oFApMTEwQj8fZv39/W2JY7efm/rSxIHZsN/E/JjlCcqsN46gJL7sQzQ26FCXuM1HPS4wS/QLftPz31Ths4PuBw1aLjIL+bR392zoBAohtAuNeoxxJWkdu/OQmO3XaKolEgs7OThee0auLJ4qvMao5VtQTPE3T1qVHnFAphj09PWUxtHF7DFuhUCCfz/P000+zf/9+Dh06JH0fw0zDytcb57X6SwIcFmzUwq02DMMw0JEvXso21jwbJaNF19KP0o53h4n6fbnvqxkysZYNFEvOcZVVBd//9OH7n2ufPavXIv9zJYxjYs37co/7biVO14dkMtmWr+nNiieKrxEa2TfVwhZFJ1iWxfz8PNPT0/T29nLq1Cn8/s2RlIyB4NUoFApMTk5y9epVNE3jzJkzru2Tpp7TG4pddLuJT3aUCK60YRjDBfRXXGgHGDLhWReE9qiJ+pzEKLFToEvcm7RRTgiCP3Bxm+CqgvGvOnxx7bmLERPuM+E+A17njlOJYRiOWkcSicRNZ+cmA08Ub3KciqGNE1G0LIu5uTkuXbpEX18fp0+friqGNrIjxWKxyOTkJCsrKwwODnLw4EHOnTsn7fjVSD3deAHdU5AfJbrVhqGH3Lm0FcldKGsHFWhJuYfUDpooTez5tYJ50sQnsSq2Gvk3bMgajGlrfz7vh4BAnLomkvcbcMSSMnzdaaSYSCTYsWNH+0/gJsMTxZuUdsXQphVRtCyL2dlZZmZm6Ovr4+67725qYLYsP0VbDJeXlxkcHGRkZKQcGcocCl7tfUw1SF+qAyb/5X6Vw/cbDC1A3xR0jKmoi+1Frq60YYy4VHE6aroyqFy500SRORlol4X+pNznKbZZaC4UFlVidJqUYio1z1JQ4DF97c/vB6DXQrzehDca8EZzrfjJyXmbKLSpRiqVKvc23kp4oniT0ayxb7M0I4qmaTI7O8vs7Cw7d+5sWgxt2o0Ui8UiU1NTLC0tMTAwsE4MbezxbG40Q+cvqZSW6ovbC28WjAU1xgZUGADOrH19V8Hi+IpgeFGw+xJ0jqvo00pzEeU2C1xI8RFxZx8qW8oQQXJhRUigxeSmxLVdFsq03KVNDAk0yUK7kdXbc/hfrO0Ws4klFf6HCv/DB4pAHLLgjddE8m4TpcmMqFNRTCQS3p6ih3s49TJsRD1RrBTDXbt2cc899zi6OJzuKZZKJaamprhy5QoDAwOcPXu25p6hzEjRHgLu968Nnk41qKRUh02e2qfAlc3fWwyoLO6Bb+0B7lz7WrQkOLFqcvCyYO8MbIsp+GIqSnFDT9tBF9wwDrgTzXHYIHJBfqWhekxuoz5DJprEClYA624D3Q3XkgpKIyb+C23kpoUCP9TW/vxXPwQF4sw1gbzPXPus1cDp4PJkMuntKXrIxy0xtKmW2jRNk5mZGebm5ti9e7djMbRpNVKsFMN9+/bVFUMbGfZR9kzWWCyGqqrlO2Tfv94B1C6e+MH9EFKg2Y6slE/h33o1/q0XOLb2NZ8luD1hcnhJsPeSRfRHRbriIfm1oduEK5WhrQzebpodFqrkoh1dl/tcrZ0W2gX3p9LkdwCXJb7HeQW+q6/9AcRbSyh/ma/6UC9SXI8niq8SlmVJtW+qRWUUZxhGWQz7+/vbFsPKczQjWKVSienpaS5fvsxtt93WlBi2eo5q2NZVsViMaDTKyZMnyyOqCpkSr0xEa/6sOVzgO30BjiqGo3PblFSFZ7ZrPLMdGIXwWwU5UyNkCgaygttSgl1JQc8qbFuGyLJCYFFBvaxsijBrMmCCxArOMsfc2aM0dxXwLUgsp7zdRHtK7jQcpU+gPO9ud33+rIF42d2lODEcR8TzdHR0bNoacdqn6LVkeLRNpZfhhQsXGBkZQdd1V2cHappGqVRicnKS+fl59uzZw5kzZ6Ra2jQqtDEMg+npaRYXF1sWQxtFURylT1dWVhgfHyccDpfdOuz0KUDxlSCiWPu5fOcNazcU+VQK2N7y+WsRUA1yZoCcpvCjqMKPosCezY9TLcGegsW+jGBPUtC7CtuvQnQZQpcV9EUVJXnt87NDwLQLUWKx8WNaxRwoEnhOXmuDUAT+q3Jfu3XWxPeYu0ukFRQUr7o/0qZwX5rEUpypqSlKpRI+n69srG076LR6TXrpUw/HVDP2zWazZSsntzAMg5WVlfIEmDNnzrhSqFJrT9EWw4WFBcdiWHmOViLFeDzO+Pg4fr+/rqlxvapTcdzkyd1rg6S7IlGuZlp7zvXwKU1WBKsKsyGF2RBQo/q9qyTYn7XoT8G+kwa9i9A1qxCYVlDibS64x93Zo/QHW/NCbIR6l4kqUcCsARPdjak9G8jda8KTLi/DByx2vr6XnfSWv2Qba2cyGUqlEs8//3zZ6ioSiZQFMxwO11wzDMOo26r1WsUTRRfZ6GUI19Okuq47bpptRGVk1tXVRX9/P4ODg9LPY7NR2A3D4NKlSywsLLB3717Onj3bthg3W2iTSCQYGxtD0zQOHTpENFo7NQr1+xO/9fqK/0ge2KMp8g6Y8ClM7lR4ultbq4ytoLdgcXhVMLgi2L0E3XMKkRkFbUZBMRqJklhzrZeMcsJAfUre0iOCFr5xibN9NYESACXncgvGbguzhoejVN66OfXv9/vx+/1s376dhYUF7rrrrnIGJZ1Ok8lkmJmZKd+8h0KhslhmMhn27KmS1miSb37zm/zar/0apmnyK7/yK/z2b//2uu9funSJ9773vayurmKaJp/85Cd54IEHHJ+vVTxRdIFmjH11XZc+BWbjnt2ZM2eIx+OsrKxIPU8tKvcs9+7dKzUybRQpJpNJxsfHEUIwOjra1EzG0rJCfrr687PuNHl62/XvmRLHjwEIyWPxQj5Rdfj3UkBlaSf86871X9ctwWjaYiRusXcJ+uzo8pKKYqchT7owfk4XaFfkpgvzw2mCTzuvjBW6wNohKPUICt1Q7Lfo+6r7S2PuoOXKeL9NvK32fnjlNaUoCoFAgEAgQE9PT/nrQgjy+XxZLD/72c/y/e9/n6WlJX7+53+eY8eOcezYMd7whjes+7lqmKbJhz/8Yf75n/+ZvXv3cvr0ad7xjndw5MiR8mM+9rGP8c53vpMPfvCDXLhwgQceeICpqSnnr79FPFGUSDXHiloFNJqmlXsR26WymnNjmrKdMW/NYpomhUKBc+fO0d/fLyUy3Eit6tN0Os34+DiGYTA8PNzSxn/NVgxV8PUNFpRFOb+qMqJ2i7YjAnpr+62GqnChU+FCp7opuuzOljiSguGcIHKXQTQFkTQEVxUCCdDjCmpcQXHg06ielNuCIbZZdF3cnA2wdIviNoNcV4lcl0m2G3LbVTLbNJLbNOIdGsshuBxUWPIpCOW6UO/rFoh7BP/78yYHv66itTmgoRqF4wbiRgjiDgvuqn39NzPNRlEUQqEQoVCI3t5eHnroIXK5HD/5kz/JRz/6UV566SWee+459u3b11AUz58/z/DwMAcOHADg537u53jkkUfWiaKiKCSTayOOEolEW1GpEzxRlEArYmhjp0/boVgsMj09Xbe1wU1RtFs7ZmdnAaQX8FSyMX2ayWSIxWLk83mGh4fp7u5u+Zi19hNLp01e6Fz/vWyzFaBNYkm+9HSJ6/bVsI9/C8OPNItEf+0Dh01BX0HQlxd052F7RtCVho40RJIQTCr4V0FfVVBXFBQfqNdcO4QqwA/419wshI/yH8svEDpYfrB0sHxg+sDSBaYOOVHE1ECL+DG6BVlDId4BKxGFpRBcDqis+BSEcu0ELZIvKiwFVT5zj4p+WvCTMwav/45C9JycGz1LFRS0G2TM+2MGSp3PhtPK09XVVbZt28ahQ4c4dOgQDz74YFM/Nzc3x2233Vb+/969e3niiSfWPeajH/0ob33rW/mTP/kTMpkMjz76aMvPrx08UWyDdox92xGrjRNg6hWwuCGKlWJoV7OeP3/eNUGE65FiLpcjFouRyWQYGhqip6fHUbGSsCD1bJXnqwq+dmbze5ktyV3ESkLyXpLkNVYRgnSh/kGzmsJUWGGqSVP7wxGD+asaeVVgrvudtfrkr//eBjtNZq/KfS9XM9dvvgxV4R8GdP7hF+HIgyY/9aRg3zc01KTzNzz/BhOqffbcoE7qFNpzyHCr8vRv/uZveN/73sdv/uZv8vjjj/Pud7+bl156yXXTdBtPFB0gw+XeSaRYOSh7YGCA4eHhhueVKYr2BJyZmRlXWjvqYVkWly5dolgsMjQ0RG9vb1uVu7kxFTO1+ecLrzN5JbL+NUVUgSF5EHjekmu/npTcMtLhE+QNuYuQ6YeM5AgpLzmC92uCklH9M30hqnHhzRC5z+KnXyly96M6wRYb+60ugTF1g1yFQwJeX//ab6dx34mXYn9/PzMzM+X/z87O0t/fv+4xn//85/nmN78JwNmzZ8nn8ywvL9PX19fy+ZzgiWILyBBDG13Xy71yjai0UNo4KLsRMoZ1Vw4K37VrV1UxtCM52Xdz9mtfWFhg9+7d3HnnnVLaWKqlThVd8P+d3vz8o6pFQeLsGRVBQZIfn40/HAWJThMRv0U+J3nxdmEkayovVxSjQYur6fq/64yu8tdHA/z1UbhjJs2PPyYYeCyCWqff1SZ76ga0YNjcZzS0mnI64s3pNJvTp08zNjbG5OQk/f39PPzww3z5y19e95h9+/bx7W9/m/e973388Ic/JJ/P09vbW+OI8vFEsQmadblvhWYKbfL5PJOTk8Tj8bKFUquC0K6fYqUY1puAY1eHyhJFO0VsO2b4/X6CwaC0vs5qoph+g8lkFculiCooSDnrGlG/RbIgN+VXaNhe0RohVb6ClSRX8AY0QaFBirdVQi0G8M/d1sFzPwc7ftrgJ5/OcOJbfsKL1dusSgdMLBe8KGvy440zUU4jRafTbHRd57Of/Sxve9vbME2TX/qlX+Lo0aP8h//wHzh16hTveMc7+OM//mN+9Vd/lU9/+tMoisIXvvAFV/u5Nz3HG3am1yCtuty3Qr30aaUYtus072RmaKWfYrOuGbI8FSvbSgYGBsrGwlNTU9IGghsZyL6yfnFS/IK/u7P67zYo+XoM+wRJmSoLpEuSozqrBMhN8eartIy0QzRgsSr55sLfYhWvzXJQ5wv3RlFfJ3jbvMnZbxXoOx9CqUi7r0QzhJflD1Wviibgx9wTxXYMhh944IFNfYe/93u/V/73kSNHeOyxxxwdWwaeKFZBlpdhPapFcLlcjsnJSRKJRNtiaNPKz280F27FQqpdUaxs+K82/UamkXHqGRU2RC2JN5rMBapfDj7JQZPThbcWqiLIShYc4ULFcrogV7jDPliVekTaNu21FIVv9Gt84xfDDD5Y4sHnFIa+oVEcNgn/8AYJIsApE6WJLWbTNB1NpUkmkwwMDDR+4GsQTxQruBFiaFMZKeZyOSYmJkgmkxw4cIDDhw/f0HSBZVnMz88zPT1NX18fp0+fbvlCcbp3WenY0d/fX7Ph36k9VTUST2/wagwJvnKi9oItO+GlS/7VdgQEccmRos8vcVA34FMFOReKYmRjSpypMBX18UdvgODrBB9+VrDrh/KO3ZAGVac2hmEQDjdZPlzBreqQAZ4oAteNfWdnZ9E0jb6+PtdFyS60eemll0in0xw4cIAjR47ccDFcWFhgamqK3t5eR2Jo02okV7lf2Yx9lW311C6pVIrlH3RQ+dGfuSfFkr/2XbyQHDSpLqRj45IjxZLkYQVdAYvVouSBDlKPtkZR8t4sQF5T+OybNX73gknABbeRqrQgip6X4nq2tChudLm3LItisei6MGWzWcbHx0kkEgwMDHD06NFXRQynp6fp6elpSwxtmo3kKqPSnTt3Nm1f1a6fov2eF2YViJ+6/rw7LB45Vd/tvFSSO5LNkhzgtDrNphlysvcoSxlAbvpQ8qQ8ALKSC3fsw9VmAAAgAElEQVQAdE0QN1T+5D0Wv/lxgbLq7rVeGipQ7EkRtsINayCc9im2s6d4s7MlRbGWsa/P5yOfr27EKYNMJsPExATZbJbBwUHS6fQN6b2xBUVRlHJk2NPTw6lTp6RNuW8UKQohyufesWNHS/uV9vGdFNrk83lisRipVIrh4WGMWB8zFd9ffJNFwl//MkhnDZxMRqmF7CpMmdNsbNKSU51dHSFWJV9asqM6hcYDC5wQjVgkDY3JsMrXP2jy9k+qrhhB22Rfn2D+0iUymTVbF3uYd0dHB5FIhFAoVL4Jb6f6dPt2eX2xNxNbShQbudzLGL1WDXskWS6XWzeFJRaLST9XNVRVZW5ujpmZGbq7u7nrrruku3PU2lMUQnD58mUmJibo7u52LMStRorFYpGJiQmuXr3K0NBQOTV98amK4p0ui68caZw6Elqw6rBtp+Rlp+gki6KfEkVTbuWp7kImRHZU1xEQpPPy7zCCAeDasvL1vRpH3mWw/2H3lt6un42w7dosUXsKVCaTIZVKsbi4SC6XQ1VVIpEI6XSaVCqFpmktXZe3qsEwbCFRFEJQKKzVwdcqoJEtiul0mlgsRqFQYGhoiO7u7huaJhVCsLi4SCqVIpFIuCKGNhsjRSEES0tLxGIxurq6uPPOOwkGnZvKNrtnaRgGk5OTXLlyhf3796/r7bRKkKpwUZ95s0VKa3wJZCRHTRnJI+NkpxGDSomc5HYM2SljRQjSkhv3IwFB2oVEkW9D+fKnX6/xB2MmoTq2ZY7ZZcGJ6x8IW/wikci6rJRpmmQyGeLxOKurq8zNzVEqldB1nY6OjnJUGYlEqkaSmUyGjo762w6vVbaMKDYzpNvn81EqtR8SpFIpYrFYeSTZqyGGdnS2fft2tm/fzoEDB1wTRLi+pyiEKLvdd3R0cMcddxAKtV/JqChK3fSpaZpcunSJubm5msPR0y8pWNcWUq3H4isHGy9KEUXuiDdFWGQl79eVJI+gCygGOalHlJ8yDuolSgW5BrcB2b0319iYKTUVhf/08wofmbJQVyRHpm81mmor0TSNzs5OdF1ndHS0/PVK8+GFhQUymQymaRIMBolEIkxNTZXHuznp2W7kpQjw1a9+lY9+9KMoisKJEyc2Tbxxmy0jitB4X6rdSNEWw1KpVBbDRtgTcmRgi+Hk5OS66OyFF15w3T5KVVWSySSXLl0iGAxy/PhxR6Xe9Y5fLVKsrGLds2dPXduqREXqNPZmi7za+OMf1eWOeOsMyG/cz0v+1eqyHZVBejvGtpDKkuT3UXNpJGmxyk3LbEjlHz5o8jOfEOsa/NumiqFwK1SaD9vYfoqZTIaLFy/yne98h9nZWU6fPs3o6CjHjh3jne98J8PDw3WP3YyX4tjYGL//+7/PY489xvbt27ly5Upbr8cJW0oUG+FUFJPJJLFYDNM0GRoaanoD2t6Ha9d7UAjBlStXmJiYoKuri5MnT65LVbrtqRiPx5mdnUXXdW6//XZX0iobb2jswp3JyUn6+vqaqmK1RVHrE/ztUHPveUSRO+It7Ee6KMpO76ouDCmVPaM06MbK5U6gSKbGkvLt3RrHfsFg9K8kvZiogNfJv84r/RQ/+MEP8v73v583velNPP7444yNjfHiiy82tb4046X453/+53z4wx8ur6E3agh4JVtKFBul4FqtcEwkEsRiMSzLakkMbez5p05FsXLfrrOzs2aq0i1RTCQSjI+Po6oqu3fvxu/3u7bPYBfa2DcAsViM7u7upttJSlchN7G2MF/8XwSlJlM/ske8BSU3nCuKkL5HKdsAOaQLipJF0Y2K20y2iBtLYqLOJJ8/Oa3xyYsmERlejW8yUFrIKDvNUqVSKaLRKD6fjyNHjqwTtXo046V48eJFAO69915M0+SjH/0oP/7jP97yc2yHLSWKsrDFAGBoaMhxFZau647EyhbDiYmJpvbtZItiKpVifHwcy7IYHh6mq6uL+fn5ciGTGyiKQi6X44knniAajbZcuJN4aq0MXu8X/N2+5hcCueUmoEuurQiqRdLI3Su2LLmKE/VbXM1LfuEuRHUlIX85DPotrtax4LJUhT9+p8L/NWmhXm7zfW8xddqOQ4YT26hmMAyDsbExvvvd7zI7O8t9993Hiy++eEMrXT1RbIHV1VVisRiKopTFoB2accqoRAjB8vIysViMjo6OpvftZIliOp1mfHycUqnE8PDwushY5mzSjcTjcV555RXy+Tx33323s7FU11KnL75FYNazIt+AbLMI2eVWnWGddFbuMYuSxSGsw1WpR0S6vyVAriT7Fgg6woKrDRziLgdUvvp/Grzr4wqK03Ydn4A3tyaK7fQouuWluHfvXu655x58Ph/79+9ndHSUsbExTp8+3fL5nLKlRLGZVEE1X8B4PE4sFkPTNEZGRqTdJTW7h1kphpFIpOUilnZF0Z4Gk8vlGB4epqenZ9Nj3BDFVCrFxYsXyzchly5dciSIQkDyGRVt0OIf+ltcdCRnnU3JIht0YZpNXnKPos+FGaUFyWPt/JogLzkNDRAICGjCNvX7fTrH3mdw7C8cLslnTJQWlyWnori6uuqal+JP//RP8zd/8zf84i/+IsvLy1y8eLG8B3mj2FKi2Ax2W0YgECAejzM+Pl4uW5adMmgkVnZ7QywWIxwOO67odCqK9qDyVCrF0NAQO3bsqHljIcPM2CaTyTA+Pk6xWGRkZIRt27ZRKBQcW0dlxxSMVYXn/jcL0UKUCGBKbiUwJB9PdsWkD4uSkCuKbhR1ym6yb8Zc2AnZbAportbgv96h8Yn7DDr/1cGy3OSs00qcpk+dzj1txkvxbW97G9/61rc4cuQImqbxqU99qupNuJtsKVFsJlLUdZ3l5WXm5+fx+XwcOnSIaDTqyvOpFSkKIbh69Srj4+OEQiGOHTtGJBJxfB5N0ygWm7hdvUahUGBiYoLV1dV102DqIcPFIpfLEYvFyGQymyLSdmafJp5S0UYsvr6r9QWgKHnAUU7yNBvZw8UjPoNMSW7/n0znCQANk6zk4eIhuS/5+nGjHU37WwlF4Y9+RuP/nrDQZlsUfQetGO14KTrd42vkpagoCg899BAPPfSQo+PLYEuJYj1sIYrH45RKJQ4fPuz6xIZqhTZ2ZBgMBtsWQ5tmI8Viscjk5CQrKyst+zm2kz4tFovEYrGyCPf29m46bzvHTz6l8oM3OvpRcpJTarLbJ2TXFHcGNDKy9ygl3wgE1QIF5PXAgjspXoBii0VLK36FL/xigV/6ZACl2c/e7SbKntafv+eQUZ0tJYrVFng7RTkxMUEwGGTHjh3s3r37howw0jStPEHHjgwDgQBHjhyRev5Gqc1SqcTU1BRLS0sMDg4yOjracqm2E9HaeN56Iux0ILiZhYyAb/c5S7fJFDFNEWQli6zsgpOAC+KQlXwjEFANqb2jID/itkk7+H0/syvIof8jxb1faDJD5bBhvx2HjH379jk652uBLSWKldjFKxMTE4RCIY4ePUokEiEWi7kyFLwauq5z9epVnnzyyXLPj1uN79UiRcMwmJ6eZnFxkYGBAc6cOeNodBO0tqdomibT09MsLCywb9++ps7rNH2afFble/e2/GMABISBYcm7RDr8gqTkfr285I+qJlschCApeZ6oT5Ff5Sw7xQuAIkg4HFr+5dNRjswabH+08efv6ukrhLL+de4XzWAYhqPh/F6keIuxsZJzY4rSLaeMjdgVraZpcscdd7i2bwmb06f2nND5+Xn27t1bdU5oqzSzp1g5kq2/v58zZ840nb5xOgpvbNXk+93OCke6dKnmGER88gVCduO+7P6/qF+Qy8ktinmtmAtHQ4JsGz2fn/pfNX5vzEKfrn0Mc0+JZH+c+ViafD6PoijrbKI6OjpqCp9hGI7mEnuieAtRLBZ54okn6vb4+Xy+lopSWmV1dZXx8XE0TWNwcJB4PO6qIMJ1UTRNk5mZGebm5tizZ09LotSIeulTIQTz8/NMTU21ZCzcDrZbxpeVfYAzd46oJre/TrYZsKII6b6HsqtjO/yCnOTp4ooLsuiGuXA4aEEbVbIJXeG/vd/iV/4fgVIjw6D9hGD//v3l/9vuF5lMhpWVFaanpymVSvh8vrL7RUdHB+Fw2HH69Fa2jYItJop+v58TJ07UvTvSdb1szimTSjG02zvS6TTLy8vSz7URRVFIp9OcO3eOXbt2uSJK1USx0q2jp6en6ZFs7VAp/L39+5gOOm+jkT3iTVPkimKHT7Bqyo3C8pL7/9zoozQkT9xRENJnswL4/ECbmYHntmmc+1WDs39S43rdsJ9ou19sbB8rFouk02nS6TSzs7NkMhmy2SzpdJrV1dWyWAaDwYZZGU8UbyFUVW2YLpCdPrVHwimKsqnXsdWJNq1iWVY5QjMMg3vvvbclt/tWqBTFyhR1Z2dn216KzSCEYG5ujunpaXbv3s2ZM2eYyuow4fyYst+pTDpNsz1rzRD2C1YlR2GyC4F8LjQpFgy57RhumQsrkp7mlw7pDD9g0Pv1Dcv1NgFnmqs/9vv9dHd3r3PueeGFF+jv78c0TVKpFAsLC+TzeTRNK6de7TRs5brRTkvGa4EtJYrN4PP5pAhV5XzUWiPhnM4+bYTtIDE1NUVPTw+nTp3i2WefdU0Q4Xp1aDweZ2xszBX7qGpUDgjfGI0uZNtb4FXJxReRjqjUfGxA8tWrIUi7kEaUTcGSO+s1EnTHXFjm9KJP/bjGx8csfGMV4v0Woy3htSyLaDSK3+9f50ZhGAaZTIZ0Os2VK1dIp9MYhsE//dM/sbS0VJ5PeujQoZYyP814KQL8/d//PQ8++CBPPvkkp06dcv4CHbLlRLGRU4au620ZDSeTScbHxxFCNJyPKjtSrLSQ2rZtG3fddVfZWNjpNJhmSSaTZLNZpqamOHz4sOv7pLDWxjI2NkYkEqkajc63KYqybQWLkvfrdMntE9GAICPZAFl2VWdItyhJjhRl7/Xa5CT+vjOawp/9ksWHPiZQMteO26Z3Yq3mfV3X6erqWrd2CSHYtWsX58+f5/HHH+cP//APeeWVVxBC8LGPfayhk0UzXoqwNtrxM5/5DPfcc09br60dtpwoNsJp+tR2jjBNk+Hh4abSC0577zZipyvHx8er+im6iT0k3DAMAoEAJ0+edP2cyWSSsbExNE3j6NGjNdtYFnLtLUqyg3jZszVNo4TMS7jDJ5C9m16Q/Jo7/CZxyalOo1jAjaUwJbkI6kKnxvc+YHD/QzoEBNzfnihunPFcD0VR2LdvH7fddhuf+cxn+NKXvgSs9Ro3E0Q046UI8Lu/+7t85CMf4VOf+lSLr0YeW04Um4kUWxHFSjF04qnYDpXj4CKRSEMLKZnkcjnGx8fJZrOMjIzQ3d3ND37wA1fPaVkWzz//PMVikdHR0YZl4e1GirLL9GW3TxQNuaodkG0JAmQkp2ODmvyGQqftPvXQVIuUC6novx3SOfhTBrvToLQ/7KplisXium0Yn8/X1LZMM16KzzzzDDMzM7z97W/3RPFmotkLJJVKEYvFqtoo3QhsMZQ5Dq4ZKueiDg8P1x0SLvOcsViMXC7HoUOH2LFjR1M/164oyozs3JhmoweCbVc3rjue5FoTN/YoZVfwAqia3D1KgEjQJCW9VGuNT71F43e25WnuKpCLW16KlmXxG7/xG3zhC1+QfuxW2XKi2O4CXukpODQ0tK6ayymtOGDbrR26rrs2AacapVKJyclJlpeXW56LKuOcBw4cYHV1ten3O1mCdJuRnswRb1G/ICF9mo3c48nWm2hAkK5jsOsENz5xOcltKADBgED6LLprFDSF9EmrLVFsZc2pxGnjfiMvxVQqxUsvvcT9998PwOLiIu94xzv42te+dsOLbbacKDbLxg9NOp0mFotRKBQYHh6WIoZwvZWhURO9XcADOLKxquYT2QytjoJzerFVUjlxp3IM3PT0dNN7sO1GiSFFUJI4VzTsEyQkVzhmJYtiOp0D5BVIRfwW6Yzkwh35xdqutGMYRhZwryd3Z0d7aWSntlGJRMKRKDbyUuzq6lrXs33//ffzR3/0R1716c2CPcdT0zQymQyxWIx8Ps/Q0JB0by97D7PWB7SykKXZAp5q2FNtmhVFy7KYmZkp39E1MwquWYGvd875+fl1vYaVx7KFvZnjt9uO0akLihLjEvkVjvKn2aDJLc4KyrcnpCg58gzo7pgL+0MBSEs/LABdAYtQm5nZdmyj3PJSvFnYcqLYrKdiIpFgdna27Dbf3d3tzoZ8DVunSjEeGRlpe8/SPk+jTfFKYWp1+k3lzUQrVE6+2bFjB3fffXfV59mKE0e7kWJEsShKtMeVvV/X4RckJE+zKZhyVUz6cHEgJ7llJBq0WCnJV29Lc29p7Yu2X2zUTqTolpdiJd/97ncdnUMGW04UG2GPPvrRj37E6OgoPT09ru6dbax23Wi0K0uMG3kqNitM9bCHgrfycysrK4yNjRGNRhtOvmmlhaXddgy/kFvlKPsTFPYLEhKn2ShCyK+WlBwcawjp5sJBl+ZZ5CRHtJXsajN1Cs4jxVt9GDhsQVGsJTDZbJZYLEY2myUSidyw9gp7qk0+n2diYoJEIuFKVWctUdzY41jZ8N8qrURyiUSCsbExdF3n9ttvb6p6thX7qHYjRTOXR+aekMzpJgBByVduh1+Qz8pdyFeTGUDeAhoNCtJpuc/R75K5cLLgnijqhWWWlvJNzyqthlOD4UQisa5A5lZky4niRrLZLBMTE6TTaYaGhtixYwdjY2M3zFMRYHJykkKhwIEDBzh8+PANS9PaE2HC4TAnTpxoeyRbM6KYyWTK7+/IyEhLd52tiG67kWI0FGY51dYh1lG6yafZrImi1EOiBzpAouFMxG+RlpjSBneqWXW1RNJwb6Tinq61as3FxUVyuRyapq1zwIhEIg2jwHYcMg4fPuz0qb8m2LKiaKcp0+k0Bw4c4OjRo2UxuhGeisVikcnJSRYXF9m1axcnT550NU1baQJcGaXVmwjTzjk2ks/nicVipFIpRkZGHBUsNRq8YHO1APl2RUhyACG7fUK2U3zIhYgpLTlaCrhQuCM7ggcI+IrIHyd/nYN7O9kRuV4lXDmrdHFxkXQ6jWmaBIPBdWJZaULcTvr0Vh4GDltQFA3D4OWXXyaZTDI0NLRODG3cFMVSqcTU1BRXrlxhcHCQ/fv3o+u66z1/qqqSTqe5dOkSlmW1HKU1e46N0WipVGJiYoKVlRWGhoY4cuSI49faTKRYKpU498plYMjROWxMyb/+ZF7u6it7rotsNwtdFWQlV8cK00D2klV0ofJU19y7ofapgu7w+s9SrVml+Xy+bBd1+fJlcrkcqqrS0dFBqVQiHA6XvRab5VZ3yIAtKIqaptHb21t3cfb5fOTzcpvKKvv9brvttnKLw9zcXFsDyJshm82ytLSEaZocPXpUWo/lRipFyzRNpqenWVhYYGBggJGRkZZ7JKsdv1akWNnbmN52e1vnAShJjOw0RUiv7DQk9lCC/Mb9roAgIVkUS8USTg2jayFzQIONolngQj8lQG+H1VSWQFEUQqEQoVCI3t7e8tdtE+LJyUnS6TQvvvgihmEQDAbX2UWFw+Gq66MXKd6CaJq2zialGu06ZVRSuVj39/dv6r3TNE26ANvYxTt2xVhnZ6drggjXI8WZmRkuXbrEnj17Nr3edqhWaCOEKHtG2uf775PtF8jkJEYQnQHBapt7nBvJS150LcmiGPYJEnIPie6Xa0OmIEi7YC4sXEz6tFt5apsQh8NhduzYwfbt2xFCUCgUylHl0tIS2WwWVVXLQpnJZOju7nYcKTayjXrooYf4i7/4C3Rdp7e3l7/8y79kYGCgrdfqlC0niiB/KHg1Kpvf64mDG6lae79yZWWlXLwzNzfninejjRCCbDbLwsICu3fvdtTS0YhqRsbj4+N0d3evO1+7jfsgN4II6YJVaUdbQ/YcVZmRMUDAhT3KnOSozi1zYQMXNj+v0e4kG5vK6lNFUQgGgwSDwXVzhe2oMp1O853vfIeHH36Y2dlZfuEXfoETJ05w4sQJ3vCGNzSsRm3GNurkyZM89dRThMNh/vRP/5R/9+/+HV/5ylekvNZW2ZKi2Ih2hKrV5neZRsOVKdrBwcF1KUtN0ygWJZYCVmCLE8Dg4KBrd3j2zUwikeDixYsEAoGqziA324g32dNsBIKU5LmaskXWjYYE2VGdruQB+SbYeeFekY0sUWym+tSOKjs7O/nQhz7Ehz70IV7/+tfzZ3/2Z7z44os8//zz7Ny5s6EoNmMb9aY3van87zNnzpStqV4NPFGsgs/nazl9aqfxpqen6e3tbTpSkmE0bKcs5+bm2Lt3b9WRbI2a951gi5Pf7+f48eMsLS1JS5VWwzAMYrEYPp+PQ4cOVTUytgQstpmq7NTkjniTPs3GJ0hacg8q281Ctqd1QBMUJD/HSEBlVeIAhDUEWevmnXlq46T61J5r3N/fz969e/mJn/iJpn6uGduoSj7/+c83fWw32JKiKDN9KoRgcXGRyclJenp6OHXqFH5/8xdFO5GiZVnMzc1x6dIldu/eXTcqlSmK6XSasbExLMvi4MGD5eHkrfQRtoJtHXXlyhX6+/sZGRmp+dilPBhtbupEVLkj3mQT8QuSErehQ5qQXoUpuy+zM2ARL8i94fL75S9/4aBFVtz86VMnY97sNdPNSvkvfelLPPXUU3zve99z7RyN2JKi2IhmBEQIwdLSErFYjG3btjmeBOMkUqwU4majUhmimM/nGR8fJ5PJlI2FN55DZorWMIxy+8qBAwfK+x71aDd1ChCUfM3Lvk8I+JDqoxjxmSTycpeCvOT9v5AP4lKPiPReVIBQwAQXZqkCdAUtaWPpnDjmZDIZR76tjWyjbB599FE+/vGP873vfc/xVC0ZbElRbHSnU+/7doFHLBYjGo227XbfalTqVIjbEcXKwp1avZ1QvU/RCZZlMTs7y8zMDHv37l1nHdUoEm13kg3Ib7uWuT8J4JNcxKIaci2jAOlzVN0Yx2ZIjmYBTBcto2TMPK2k1YjPqcFwI9sogGeffZYPfOADfPOb32zYHeA2W1IUnbKyssL4+DjhcJjjx4+3PRYNmh9ybZ87Eok4EuJ602ZqYZomU1NT5cKd0dHRuhdSu+nTyqHkvb29m9LBzUy0kREpyl5/ZbZ3AMjOXm2LhIhL3FsLurD/50YyW/bvBSAQ8oPkcXk2fRJFsdnB+pU4bcdoxjbqt37rt0in0/zsz/4sAPv27eNrX/tay+eSgSeKdbA3luPxOOPj4/j9fqlj0ZrBLmbx+XwcO3bMUfoCWosUKyO1ar2VtWhHFO05rB0dHTUj4GYi0XkZQ60lpztlN4jLjplkj4zrDFhclbz/Z8rfqnalR9GS/WZWICtSdCKIsNa47yRShMa2UY8++qij47rBlhTFZtIGmqYRj8eZnJxEVdWa1Y5ukUqlGB8f31TM4pRm90kr9ypb8VK0z9GqKKZSKS5evIiqqg1FX1XVhqlmGZFiMiHP3UFXBDnJPYCyp9lIdslCF0XA+ZZCNYqy+yhdMhcuSPa4rGSnBB9FeHW8FF9LbElRbEQqlSKbzTI+Ps7BgwdviH+YHZXa55VlLmxTL8oSQpR9DdspGmplTzGfzzM2NkYul2N0dLSpi62RdVTJgiUJ/Xt+ie4OURem2RQkz2CQ7uChyA/rspLTsR1Bi6suFMRkXPRRLManWVICRKNRAoGA4ypQpw4ZiUTilvdShC0qirU+TOl0mvHxcUqlEtFolIMHD96Q6FBVVbLZLFNTU6RSKYaHh6WbG9fau1xdXWVsbIxAINC2fVSzA7vtAeHDw8P09vY2/TobHf9yTsGSMGNL5l5TWLdYlbwjJrvRXnbEFJJcOagIQUpyqjPsg6tSjwiqKkiX3FlSfapg9zY/qVSKhYUF8vk8uq5vsoxqJgL0HDLqsyVFcSN2dJbL5cqCdOHChRviqVgsFsnn8zz33HMMDw+35SLRCpW9hrJSw/VEq3IG7MDAQMOinWo0KrSRkToFuXuAmmIi9zITpCXvUco+nuz9v46gIJeRe2Mh248SIBoSpIU7keLODoudO/uA65WZpVKpPK90bm6OTCaDEIJwOLxOLDdmfdqJFHft2tXuS7np2dKiWOmpuDE6czLVphXsHrzLly/j9/s5ceKE4yKaVsjlcoyPj5PNZhkdHZWWnoXqe4qVA7t3797d1oDwRpGijHYM2SPezFIBkBc5hX2ClMRpNj5FSJ8pKnuOqi5ygNxrw416mHBI3NDKU5/Px/bt29ddw5Zlkc1mSafTxONxZmZmKBaL+Hw+otEoHR0dmKbpyLHGNha41dmSomiaJhcuXCCRSNxwT8XKiMm2kHr55ZddmQRTSWVEOjQ01FLaslkq9xQrB3Zv376d06dPtzTpp9bxa71P6XSaFy4ZwM62ziF7xFskHAaJ7Q4RvyAlsXG/0y9IShZF2endzqCPlGSxcaOaVfe5MA3gGruaLLKx/RI3VsgXi0VSqRTpdJrl5WVyuRyrq6tEIpGyWHZ0dNQdAuIV2tzCqKpKT08Phw8frikMskWxss1ho2uGjPmntagcEq6qKvfcc0/bvoa1sEWr0cBup1RLnxYKBcbHx0mn02T997RdIBOWPOJN9uIbkHzFhn2CpMTjubH/55c9PBb51ayAO82U12h3vJvf76enp4eenh58Ph+madLf3192wVheXmZychLDMAgEAuvSr7a3otNIsZFtVKFQ4D3veQ9PP/00PT09fOUrX2FwcLCt19sOW1IUNU1j5876EYXP5yOTybR9LiEECwsLTE5O0tfXV3UkmxtRqW1dZU+FOXv2LOfPn5d6jo3YTt9jY2NS2kg2UhkpVqafh4aGOHLkCH/+g/YniYQUpNo8yZ5mI8wCMp0dAqrc6CYSEORl9Iq6TEZyNStAyb1AUdrMU7i+p6iqKtFodN/CwtwAACAASURBVF09QTVvxX/8x3/kkUceQdd1vva1r5FIJDh+/HhTdQjN2EZ9/vOfZ/v27YyPj/Pwww/zkY985FWzjQJX721ubhqlDtsVKns6y7lz50gmk5w+fZqRkZGq6QmZw7rtPbzHH3+cUqnEmTNnGBwcRFVVV5wyYC01c+HCBV566SV8Ph+nTp2SLohwXRRnZ2c5d+4cuq5z9uxZdu3aRcFSuCqhHUN2Bkz+NBu5T9ANBw/ZyB7HpgiLlOQ2GUB6P6qNgpAqivWqT21vxR07djA4OMixY8f49//+3/Otb30Lv99PNBrly1/+Mg888ACf+9znGp6r0jbK7/eXbaMqeeSRR3jve98LwIMPPsi3v/1txwMGZLAlI8VmaEcU7Z6/aDTKyZMnGw6xlhEpVu7hbdu2reoeni2Kssx/K6M128z48ccfl3LsjQghiMfjLC0tEQgEuOeee9a9joWsgpCwFyi7c032NJtAICC3mEPy2hOS7B0JkJdsAxoN4YooJgvuxBhdQSE1be6keb+zs5NSqcSHP/zhlrZfmrGNqnyMrut0dXWxsrKyzvD4RuKJYg10XW+5+tTu+fP7/dx+++1NV5O2G8HF43HGxsYIBoN19/DcGthdzb9RJslkkldeeQVN09i2bRsHDx7c9Jh5WYucxD1AN6bZyE7Hyo7CfC58DDKSxSYcsEjl5B7TrwtWXZiQA3JTp+DcSxHctY26Wdiyotio583n8zUdvaVSKcbGxgAc9fzpuk6h0Hrur/K8hw8fbnjedsW30cBu2eRyOcbGxigUCoyOjuL3+/nhD39Y9bELknoULYki4cY0m6Lk7HcyI3ckm+wl06cKspKj7aALH9lI2GLVcMcyqtnK02Zx2rxvT91qhWZso+zH7N27F8MwSCQS9PT0tPz8ZLFlRbERzaQ0M5kM4+PjFItFRkZGHJcrt5o+tXsNc7lcS6Pg2hHFyoHdd955Z8OUcDtUTr0ZGRlhx44dKIpCoVCo2ZIhq3G/KLHeKeyzWJUckWRlR56SbY4MyaLdGbRIFOWKjeZCNGsaaWTNy92ITHcMcJY+NQzDUX9xM7ZR73jHO/jiF7/I2bNn+bu/+zve/OY3v6oR6ZYVxUZver3h1pVmu3bTfzs0K1bFYpFYLMbq6irDw8NlsZB9nkrS6TQXL15EURTXHULsitnZ2Vn27dvHyMjIurRsveheRuM+yB155nchcEhJjJpUBJmiXIWQ3eoQ0iEh9YjgRg1H17YIizLLliuQ7aPoJFJ06pDRjG3UL//yL/Pud7+b4eFhuru7efjhh1s+j0y2rCg6oVgsMjExQTwel9oA3yhSrCxo2b9/P4cOHXJ03lZEsXJgd6uDyVtNs1SmZfv6+mqmZes178uKFFN5eSum7MrOsC5ISdxTjPoF2ZLcJym9sMiFwh3ZA9ABJIzcrYnsPUUnE23aadxvZBsVDAb527/9W0fHdgNPFJugVCoxNTXF0tISg4ODHDx4UGp4X0usKnsN7ek37RS0NCOK7QzshuvC1WyqJR6Pc/Hixbo+ihuPvZF0CZISIrygIjCEvPBO9joZDlik8vKeX4dPSC1kVYQlddoOuNMzlpcs3ABFyQVQNn5NsD0k/8ag1fVrqzhkwBYWxWY/FLFYjMXFRfbt28eZM2dcqbLcGClWNvzv2rWLM2fOSCloqSeKlmVx6dIl5ubmGBgY2JS6bJZmRTGTyXDx4kUsy2o6LVsrfSqr8rRTE5QkSpnsaTYhHyBRdIKSh2J3BiEjeXC3G6lO2RN3ADIuVZ52KGlefvklOjo6yuPY/H7/Dd9z2ypzT2ELi2I97JYDe+p8O0Osm8EWRSEES0tLxGIxafNCK9E0bVObSaUAtzuw2z5HvTmu9r5oIpFgZGSkpf3YWguBrNRpRBVSp9nIrhTVJU+fkd+4b5GRHNvJHi4e0AUFFwQs4cKEHID9O4Ps37+fdDrN6upqecC33+8vj2GLRqPlUWyNcNoU70WKW4BqH6BKR4edO3fS3d3Nnj17XBVEWIuuSqUS58+fJxwOS50XWommaeXWj2aa/Z1QqxfSNE2mp6dZWFhoa1+0GrLaMYKSp8UkMkVkXmKykxSSX670uawg31w4GrRYkWwuHA5YLJvuWUZFIhEikci60ZSVo9jsAd+KoqwTykgksinD1MrWRiVbxUsRtrAoVlJZ6NHT01MWiBdffNF1T8VUKsXFixcpFovceeedrlZ32unTyoHd7RoLb2Tjvl/ljcbGQeiykBUpym1OgJIi/8ZGJrLTu7oLwVIiJ1e5Q3KGOa0jEhYsSxgxWI1alaeBQIBAILAu02KaZlkoFxcXSafTmKa5zl/R7/c7uv5WV1fp6+tr/MBbgC0rivb+1MrKCuPj43R2dm7qv3PLPgquGxsXCgVGRka4cOGCq4IIa6nLxcVFEomEKwO7Yb0orqyscPHiRamRaDXmJVWLyNxi86mCvOTUnyG5xNEVpwiJRPwWhazcGyifC+bCAb8Al0SxlcpTTdPo6upal+YUQpDL5UilUiQSCVZXV8lkMjz77LPrLKPC4XDdGoJUKsXw8HBbr+W1wpYVxWKxyJNPPkkwGOT48eNVoyU3jIYLhQITExOOew2dYO/jraysEA6Hueuuu1w7l6ZpZacMTdOkR6KVWJbF3Nwcs+lBSQeUcxhYa3eIS55mk5dswyB7UozskXFRv6Ag2UfRjStNdWl3RcYgcEVRCIfDhMNhdu7cSTKZZH5+ngMHDpT9FVdWVshmsyiKsslf0U6/JhIJqYbkNzNbVhR9Ph9Hjx6tO59UZqRoGAaTk5MsLS1V3VNTFAXLsqRWt1Z6Ke7fv5/+/n6mpqakHX8j+Xyeq1evEo/HOXr0qKt7EEtLS4yNjRHYvouipI+xzBFvIZ9FXPI0m2TeQNYlqwghdRAAQF7u/aMrPYpFQ767sAttjwBsCwn8kldou3G/0l/RxjRNMpkMqVSKy5cvE4vFOH/+PN/4xjcAGBoa4tChQ/T397d8I3/16lXe9a53MTU1xeDgIF/96lc3iexzzz3HBz/4QZLJJJqm8Tu/8zu8613vav9Ft8iWtY5SVbXhwG4ZomhZFlNTU5w7d45AIMCZM2fYvXv3pg+VTAG2+xufeOIJNE3j7Nmz7NmzB13XXbGOMgyDsbExnnnmGSKRSFsj7xphmiZPPfUU8/PznDx5ktDuIWnHljnizY1pNgVRu4ezVSJ+gSm5t062R6Erw8VzkpUbyLukirKb9qH+iDdN0+js7KS/v5+DBw9y11138f73v59PfOITqKrK+Pg4H/jABzh58iSf/vSnWzrvJz/5Sd7ylrcwNjbGW97yFj75yU9uekw4HOav/uqvePnll/nmN7/Jr//6r7O66tKYoDps2UgRmhsKns87awyrLDBpptfQFsV29t2EEFy5coVYLMaOHTs2TYaR7adot65cunSp3Mc5MTHhihdaoVBgbGyMfD7P8ePHy/sm83F5C5LMEW+y2x2CuiAjUcQ6fELqNpiuyB8Z54bUmC4UP6VdGAYA7ohiqyPeNE3j2LFjmKbJf/yP/5He3l6AlreVHnnkEb773e8C8N73vpf777+fP/iDP1j3mNHR0fK/9+zZQ19fH0tLSze86nVLi2IjnERvdq/h+Pj4ukrWRsiwj7p48SKRSKTmwG5Zolj5Gnfs2LFO8Bv1KbaKaZpMTU2xuLjI0NAQiURiXYGQrMpTkD+iTCYRv0WmIC/81MwCIG+vtzMgpEwVqsSUbS6MIC25cV9RhGs9irJnnoJzh4xUKrWugKdVT9bLly+ze/duAHbt2sXly5frPv78+fMUi0WGhuRlgprFE8U6tCqKtpNEPWGSdS4be2A30HAyjAxRTCQSvPLKK4RCoaqvUZZnY+VQgf7+/vKIu8nJyXWzVWVNswkogqLERVjifQEAQR9SKxz9kiPZiE+QlHtICpILvzuDgqTkfd5QoERGuFNV7Vb6tN4oxXo/10gIf+zHfozFxcVNX//4xz++7v+KotTdk1xYWODd7343X/ziF131aa3FlhZFWZ6KyWSSsbExVFV17CTRqmBVOnWMjo42VRnWTpVrNptlbGyMUqlU17ux3tDuZrl69SoXL16kq6trU6RtH9++WGQ17ndJHvEmexamX3IrQUBye0zAhVaHjOSoLuy3pIti0GeC/G16AHZK9lEE5wbDzWyJPProozW/t3PnThYWFti9ezcLCws1ex6TySRvf/vb+fjHP86ZM2daep6y2NKi2Ahd1+vmzm2hKBaLjI6OtjUGqdlIsVQqMTk5yfLyMkNDQxw9etTVlo5SqUQsFiMej5e9DethT+dxgj0PVQjB7bffXrUQSlXV8gUqBCxKihSVfAZozRy6HjL3J0H+NBtLsoapkj+CmiKkF+743Wjcj/iQHiKzdpOxLSj/RsOpKEJ7N9W2Z+Jv//Zv88UvfpGf+qmf2vSYYrHIz/zMz/Ce97yHBx980PG52mVLi2KjX3ItoSoUCsRiMZLJZLnXsF00TasripUDu90cTl7tfAMDA007gziJFCvnoY6OjtLd3V3zsXbrCsBSXl5E1h0OsZiScijAveILWcieKZrN5pB5U9EZFKQk21rJLn7i/2fvzaPjOM9zz99XVb1iB0mABEiABEGQoEiJpEhJ3u04GtuJ78RjO3KS0bE9ceLMiZTYseNEieP4Os71KFESbxlvknOVe5051zpzE09iZ5wz11Ys2RIlkaK4iCAALlgJgAAIoDd0d1V97/zRixogll6qZUvEcw4OSRCoqu6u+p7v3Z4HoEozii21mmrsdcsxGE4mkxXLTj7wwAPcc889fPOb36Szs5PHHnsMgBMnTvC1r32NRx55hMcee4wnnniC2dlZHn30UQAeffRRDh06VNG5S8VNTYrroTAqgaUWUl1dXfT29noWpa02LrGSY0Y1tVhFhMnJSS5fvlzW+UpJAxcS786dO4vSQy0kXa+MhQH8Hi5A1VGz8fRwLHocySrDu3ERyHpHenrE6jhueP255NAcSHk+twzlRYpeiIFv2rSJH/zgBzd8/+jRozzyyCMA3Hvvvdx7770VnccL3NSkWCyhua7LyMgIV69erVqUZllWXqw7h5mZGQYHBz2XSVvNBDhXy6uvr+fo0aNlFeSLiRQLR0daW1tLIt7COrCXnaeGh/nEWp9m3vV24+JlExBAzOPUpK29XUqCrxBz4cUqzSgG3OucPJlpoFuuMlNq52chHMcpeVN9MzlkwE1OiutBa006neb48eOe2CqthcIIKxKJ0N/fj9/vr5pgd+HryHWwKqVWreWVevzVkOtezcnNlUq81YoUDQ91RQ29CHirY5vwMLILmt7bJ0U9Jlmva5QAi1VIaUeqNI5xYNcmjrYfQ2udV5mZnp7m8uXLuK5LKBTKu2HU1dUV7bFYjkvGzeSlCBukuCIKIxkRKTtqKgWWZZFMJjl9+rQnjTurIUe+ORupixcvEovFiu5gXQ+rkeLi4mK+KWmt7tVijl+NSNHLmbiGmiDX054dDoCYhyRW59fMJ73b3AVMIeUxOcRiccDb+9/rGUXLFCIeCxbkkBvHMAwjT3w55ES+Y7EYCwsLjI+Pk0ql8Pl8+Z/NiXyvRJSllnzm5+c3SPFmwUo3R841o7a2liNHjnDu3LmXRbB7ZGSEmZkZbrvtNk8ad1aDaZqk02lGR0fzA/H79+/37DUuryk6jsPly5eZmZnJd69Wcq7CRhsvSdHLxhPT49slYAoJD0k7bOGpmXJ9QDPnobAAgM8fBg/FwKthLlwX1kQ8TpNDVgi8ZvVsS6HId+FoQ85jMRdVJhIJTNNc4rFYjtrUzeSlCDc5KRYiEokwMDCAZVkcOHAgn0LMjWVUw/aoUK2lra0N13WrSogiQiqV4vnnn6ejoyM/EO8lcpGiiOQl4Hbs2OFZHTZ3fFfDNQ93/l6KWQve1sPCPoeE7d08QcDw+PosmPP0iJByvCWbapgLh4JA3NNDAtBUphD4Sh6LjuPkPRbHx8dJJBI899xz1NTU5IlyvTrlRqR4E0EpRTweZ3BwEMdx2LNnzw0ffjU8FXOWRyMjI3m1FsdxmJmZ8fQ8hcjJsrmuyy233LLkwfEShmGwuLjI8ePH2bRp0w36q5Ui12gzuQiuh3VAbyXevN1omJICvCNFrxN+XgsLgPepzmqYC5tVaAYCb5VsLMuisbGRxsZGXNclkUhw+PBh4vE4sViM6elprly5guM4S+qUtbW1BAIBlFJEo1F27drl2TX9rOOmJsVUKsW5c+fo7u5elSS8JMXlgt133HFHfofmtVh3DoVNO4cOHWJoaKhq843RaJS+vj6SySR33XVXxbNNK8EwDKLRKD/umwUOeHLMgBJSHqYn0x5/jHU1QaYWvDue16MJXt9NQUtIeUyKyUQE8NgPsEpjwtWQd4OXZhQL65Q5PdKV6pQvvvgiDz/8MA0NDUQiEY4ePUpPT0/JjTrF2EblEIlE2L9/P+9617v427/924pfczm4aa2jIJNuuPPOO9eMmrwyGp6bm+PZZ59lenqaI0eO0NPTsyRl4YU8WiGSySRnzpyhv7+fnp4ebrvtNkKhkGfapIVIpVK8+OKLnD9/nt27dxMOh6tCiMlkkunpacbHx/G37PTsuPUeRzpezwAaytvr89oM2Gt1nLqA96RQbmPXWkh7mKkoRDXk3WDtGcVcnbKlpYXdu3dz22238Wu/9mt861vfoqmpiWg0ymc+8xmOHTvGn/zJn5R03mJso3L41Kc+xRvf+MaSju81bupIsZiGj0ojxWIFu71qdCmUgevu7mbLli1Lju2lp+JyB4v9+/cjIp6Se+48V65c4dq1a9TV1dHa2sqZ+eLF1tdDrSmeNp54rWbjdZIuntJ4KcWS9lioIFSFGqXXxA2Q8N6aEahepFjOjGJ7ezumaXLfffdx6623ApT8fBdjGwVw8uRJpqamePvb386JEydKOoeXuKlJEdYXBV9P/3Q1lCPYXQlyxsJjY2NrCgx4ESkWquy0tbXd0LDjlZ9i4Xm2b9/OXXfdxdDQUMar0sPO0xDedWP6q6Bmoz1O6HhtkZXw+HjVqFF63XkKsJCqTqKtGpZRkNlcllPfX1hYWNJ9Wmr5pRjbKK01H//4x/nWt761prD4y4GbnhTXg8/nI5Eovje8cATh5RDsFhGmpqa4fPkyLS0t6za2eOHb2N/fv6KDBXgX8c7Pz9Pf3099fX3+PCKCYRgZ8l9sx6tox0uJt9qAMOchYYO3jhs+JSRdbx/7qNcehZ4eLQOvxcUtI03E8b4jPWAKjaHqNPCU66UYiUTW3dRXahv1la98hV/4hV9g+/btJV+f17jpSbGYSLGY9KkXgt25Gbxify9HHKX4N5qmWVbkm0gk6O/vX9PBwgssLi4yMDCA4zj5dLOI4LouWmu2bdtGsKaO+bPe3bpeBiY+bMBboQcv03S1fk0s7V3qtManSXlsx+S1F6XCe8eNxnqTiMcCDVC91CmUT4qJRGJdVa1KbaOefvppnnzySb7yla8Qi8VIp9PU1tauWX+sFm56UlwP65HicsHuSkYQcudabyYyZ7GktWb//v0lNRGYpkkymSz65wuto3p6eqo2yuE4Tr4Wmhvyz9Unc3OPSiksyyLhb0K8jCc87DsyxHtS9LJGWWsJMc+OBgFSpPC2qSrt9ZB9UIh6TNwBv0A1SLFKTTZQnkNGLmCopGO9GNuof/iHf8j//dFHH+XEiRM/FUKEDVJcF2uRoteC3eulNnMWS/Pz82UTVLHp0+UOFsVaR5UKEeHq1asMDQ2xY8cO7rzzzryUW44QlVL5h/KMUny80U/tYZed1yA2o5irsLbjZWRSFw4xuejd8fymeCo6HbS8Nu5VRDx8veB9zbMmoD0nRaNKK2e1I8VydZQrefaLsY36WcJNT4rrfdgrjWTk1G98Pp+ngt2rEbDrugwPDzMxMcGuXbuKslhaDeuRYuEsZUtLS1VF0HP1ycbGxvzMZmGqFF6qQcSBz1o+vmZauEpBC5kv4NCC5rZrgppWTEZVyVFkNJYCPBJd93jfUOsXT4WsvZagC5UjvbIGlIjng/uBKqxyHpZ5lyAxfYmLZio/RxgKhTzbjJbTfZrblFaCYmyjCvHBD36QD37wgxWdsxLc9KS4HgqJKpFI5EWtqyHYvXxcYnmXpxcEtRYpFjpYFFujXA2r2VNB5n3MpX9z9cnVyBDgu4bJJ3w+xtTKu/0XGgxeaAD2QHtSeM2US+MMTF03impScZV3DROuxxv9kMdpOs/XcvH2BdcGhcW4x4pAVSAwL8UeCnH7vm3UqwWi0SjXrl1jcXER0zTzJFlXV0c4HC4rnVlO92k0Gq3KjOfPMm56UlxvF5Rrfunr62N+fp7u7u6KRa1Xg2maeQKenZ1lYGDAcy9F0zRvmDNKJpMMDAyQSqUqcrDIIZf+XP4e5TpzZ2dn8+nfleqGud8bR/Fxn4/vmcXfpuNBxf/daUIn1DjC62dcdkxDZMZgYZWIa9FDnU2v1Ww8DsRwPL4+rb0lMJ8kWfQqas+iGr2c8SqMeCiE9iYLv7lpSWnEtu280Pfw8DCJRAKl1BLrqJqamnU3zOU02txsuqewQYprIjecnkgk6OrqqihtWQwsy8rf+KZpeu6lCEvnFHPNLdPT0544WCw/R243KyKMj48zPDyc78zNdf2uVDd0ga+aFv/J8hGr4HriluLftpqwFZQWjkZcbpkCmVFMxjLnCigh5eFcYdLjxdL0eBTOS+FzANv19gJrAyYRD90xoArmwkqYr4KPYnNY8K/Aaz6fj6ampiVjEa7r5olyfHyceDyOiCwxJK6rq1tCguVEijeblyJskOKK0Fpz9epVhoeHaWtro6amhm3btlWVEJPJJNeuXcNxHA4ePFg1q5ZcOnh0dNRzB4scCiXrchFvc3NzvjN3rVTpSWXwEZ+f0x7rs4qheK7R5LlGYC90LmrumhJaZgVxjUxasfDjVZl/Oo5D2k7jsyx8fh8q9x9k3DC0q3G1i85+JZJ+wDu1Ha+xEHfwUs0mnvLsUAAEfN7Xr702F64LCQmPI2QorcnGNE0aGhqWENZqhsThcJja2loWFxdLnlHeiBRvQhQSnYjk3SQ2bdqUb/6Ympoqy7G6GBRGa42NjYTD4ap6l83NzTE/P099ff0SQXIvYRgG8Xic8+fPA+Qj3rXIMAL8meXjYdNCV3Hz0aE17SLgh6c6FGOd632m/uzXajABH34R9ivNFdfgvadT2Jcs0h547bke5v4M0SS1d/VTAyHqccQkVdBj87pxJxzUkPzpkuJKWM2QOJFIEI1GSafT9Pf3Y9s2gUBgSZ0y54ixHDeblyJskGIec3NzDA4OEgqFbmgyyXWgekmKhfZROQmza9eulaSeUwpisRj9/f2YpkkoFGLv3r1VOY9t28Tjcfr6+ujt7aW5uXnNuiHAs8rgUz4fDnCXaAzJ1IEcwAaSQBxFTCkigF0kaSoR9ojQIkIauKIMRpXBqMec6xehV2lOmiaY8I1jAVoPCr98ziV+0SBdQfrOyxplXQASHqaK6wJC3OOmGMfjtk6fckg53i5zPj+Zm9JjVGMcQylFTU0NNTU1jIyMcPjw4byvajQaJRqNcvXqVVKpFD6fL0+StbW1BIPBitOnxTpkjIyM8Bu/8RuMjo6ilOJf//Vf2blzZwWvvHzc9KSYTqd54YUXEJFVm0y8to/KRaObN29eMuxf2GjjFVKpFBcvXiQWi7F3714aGxt56qmnPD0HZEh+bGyM0dFRfD4fvb29NDQ0rFo3zOG/mSb3+fykSogOwyI0iFADhBH8knEbNAGfFiyBOaUYNAwGlcFg9QJPAiLsVZrnl22YpoKKvz1qsn2/8J5zLvOXjLIWfC9JrNYvJDw0xa31C3GPTXZTjrckWxcW5rxUKwBWaYKuGNWcUSyEUopgMEgwGGTLli3576fT6TxR9vf385GPfATLsmhra2PLli0cOXKE/fv3l5RdyjlkPPDAAzz44IM8+OCDK4qBv//97+eTn/wkd999N7FYrGr2dsXgpidFn8/Hzp0719T284oUFxYWGBgYIBgMrjjy4LWDRW62MedgUa2aaE7EIGcq3N/fj9Z61VQpZCLB/2j5+Osy0rcJpUgsey1drqbdFZ4Tk7RStGvNbaI5bRhEjeq87hwhnlojgzAWVnzxDpOu/ZpfOquZvWKUZI68sKjxyuEt6HH2P1iF1cPrVGeN3/DcccPbbetLeLlIcTX4/X42bcp0vu7cuZNTp07x2c9+lnA4zMLCAn/9139NQ0MDX/7yl4s+ZjEOGefPn8dxHO6++26AVZ2EXi7c9KRoGMa6YrflOmXkkJtvtG2bvXv3Ul9fv+LPeREprudg4SXi8TgXLlzANE0OHTpEKBTKp0enpqYQEWpra29IO8eBD/n9fLeEUYvVcKvjEnLhBYzMHGN2TR1XBuNArSu8QbsMKcWoh62cQRH2rEOIhbhca/D518C+WzTvOKOZGTHQ65Cj3xQWxbtH1Ofx3sDr+T+f4a1QAYBleGuTBZCswoxi0KqeEDhQkqZyIRYXF3nrW9/K2972trLOW4xDRm707N3vfjdXrlzh53/+53nwwQerJhqyHm56UiwmevL5fGWRVaFuaM7bcC1UGpHmFGIKnSWqAdu2uXjxIgsLC+zdu5empqYladIdO3YwPT3N6OgosVgsP3xcX19PpLGR/62pibNG+Te8qYVjriauFReUueZEekwpnsbE0MId2iVlwOkKH7agCN1K80IZx7lQb3Dh9XDbvOatpzXXxoxVFXi8VrPxein3+ngNQWHeY1KsRnJkPuE90bZUOUosVww8Go2u22hTqUOG4zg8+eSTnDp1io6ODt73vvfx6KOP8qEPfajk6/UCNz0pgndOGTkU6oZ2dnYWrRtarq1ToYPFgQMHiko/rKU4sxoKPRt37tyZn9tcXjcMh8N0dnbmHnFf5QAAIABJREFUf89xHCKRCE/YNr9bV8/1MgkxmCXDMa14fh0yvOHaleJ5TBDoiCbYojTnwjWkSkythkTYrXTFxHq60eD0m+DorOZNpzWTEzcez2s1G68H970+nl85rN3pWzq0eKyOYwgxj623oHoeijmUS4oLCwvrNtpU6pCxfft2Dh06RFdXFwDvete7OH78+E+NFH961cxXEIolxVzq8umnn8Z1Xe666y62b99eNPmUSr62bXPhwgVOnz5NR0cHR44cKYoQV1K1WQ/T09McP36cdDrNnXfeSXt7O5CpXTqOkyfElV6rZVn825YtfKhzJ9fLiF43ucKb0i4NNjwjJuMVdjpcDYU5Hayl3oU3Oi4tRb4XIRG6PCDEQpzYZPDXP2cydLdLa8tSlllpkLsSLES97Wz22rhXO963dHopzACZxh1PHVqyqHY9sRyHDCjOS3Et5BwygFUdMo4dO8b8/DzT09MA/PCHP2T//v1ln7NSbESKrB8p+nw+YrG1W9jm5uYYGBigrq6Oo0ePEgiUbh9UOPS+FgojtlIi0cLzFPuQ5EY5LMvi8OHD+brhWk00hSiloWaLq2lxHOoWU/iTaWxXsWAFmfSHmBRhn+HitxRRA4YMg+sVNtDMKcVTmPhc4TWuy5wBF1Z5T8Ii7FLCmSrVOX7SYvKTu+HnJlxuO6O4NmN4rmaDVZOZcfEIXs8o1tfWMONxN2vc48adYMAFjx03oLqWUVCZwXAlc4rFOGSYpslf/dVf8da3vhUR4fbbb+c3f/M3yz5npdggxSKwVgQXi8UYGBgAyJvilov1iG25g0W53o3FdLmm02kuXrxINBrNj3KsN2+4HCs11BhaaBOhFSGsQUtmzs/vKGwNV12LC/ghCPUi1Itmt5vGchwc28bRGp9h0mNZuJaFYZpcwwAD5g3FvE8hJfKWrRTPZVOrt9qakBJOGAZulnTDIuxUwhnPWepG/HCbyQ+3wXvHXPSY0GpoRAARUqk02tX4A34MZWY0PbN7OSniT8fDVKylhITHajYea4ujEGIeX6PPr8BjqywA4hMsLPhXbEzzAuU4ZEAmG1VJb0KxDhl33303Z86cKfs8XmKDFIvASqSYSqW4dOkSkUiEnp4empubq3oN641zlIJC/dPlKKyH7tq1i97e3jV1SlfDKPB7Pj/XUbzRdrHJRGbjomi2hS1aCLvgCNiicMhontYKtIpmAUUcRRwTlAm+QGYYsQA12iGQcpnzWZBdUOvS0CguASeJ+AwWggGmTaPovojz2dTsNlezS2suGoomA85WgRAbRGjTmgbAJ5AC5pViXCn+e7sJ7ct/o3QzX0MLd2rNJIoRZeB3hbak0LoIm5NCQxJqkhBMgpkEkuCkFIvJjDza6k1ALjHb2+Uj7fGsQ31IiCS8/dxUFcZ7FMKmoM3ExCyxWAwRIRwOU19fv6KGaTkoR/d0rezZqxkbpEhpnoo5kfDJyUm6urrypFEtFDpYrDXOUQpWaugpFBVobW3N21SVkioF6EfxNdPi24ZFPPtzLWj2uEK3q2lLK05rk/GKXwX0moqT6sY09bwywVeT+UcStoim3RDqTEiZkDTBZ2ZufgNAZQIul5yCjmLRgIsYxAXiLrS4ggWY5P688ctAMLJ/V9ljq4KvWgRXMjqsF5RizDSIVNCFuxaUFo6KZk4Uz6qXzpE2FUM1iqGa9Y/hc4W2lKZ1ETYlhYZFIRhzseIOZjJN2A6QSIfwqg814bm5sHguLp6uAk80h4XOHW1AG7C2hmmhNFspQ/Tlpk+hMoPhVyI2SLEI5OYUx8bGGB4epr29vWrzfzmrKq11XhM1N87h1c25nBRzChZ+vz8fhZZChhr4N2XyNdPi3w0TnxZ6XU2ThmlRoMGy4bg2PWtSOKJcTuriCCWlDC7ndOOy0UiTuIQtmDMV06aB7aPItrPSr79LNA0iHDes/K8rLXRrTSuCUnBNKS4rheNBJHK76xKX0jt0l8M2FcNhxXCBUYtPm9ylLZ6TMI5SNKeEw9fSbJ+0CcwIqUiAtC5dkEGJEPXaXLgK+w0vFYZyaKlxcBwnv56sp2E6OzvL0NAQjuMQCoWWEOVqqU7HcUp23EmlUlUb6/pZxgYpsv5OaG5ujkgkQiwWq5qIdg6GYeSbaKrhYAEvkWI6nWZwcJBYLMa+fftukGVbr264APxXw+Jh08IW2OUKd9kugxj0Y9KpNdsd4QXX4KqHjc6b0Fyu0KVgTpnMuYALNYCREEyV0XlO+RRpPxWPom0VTacIzykDvewzFKUYQjGU/waEtNCRSuNLxCEY4FowyNUS0raHXBdbK14wKiPD1bDXddFa8XQB2V4PKH6www87Xlo8eyMuvVMOmyYdZAYSyVA2hl4dNQFIJn62bbcA5ha9DxW31maes9xGNfdn7tnLlStyGqZbt24FMkS5uLhINBplbm6OkZERbNsmGAzeIPZdTvfpwsKCJ5mpVxo2SHENRCIRBgYG8Pl8hMNh9u3bV9XzzczMEI1Gqa2trSr5KqWYmJhgYGBgiQRcLjrMkeFqZNyP4u8Mi9MY+DT4XZjAYCb7/+1ac8jRvOAamSYYj9GuhLNez5+JsG8xxvlAPX4bjITGsSAWMLADlEQy9SIcFM1JZTBZwoZmUSn6fX5oyBKMwDZb6EATABYUXDIMYsuiyYOuixLFWWVWZcjKn61LPisGbhHZir56k756E/ZkUts1tnD0ukPnlEPNNU1yziLpLI1AwpZL0uPlyOt+TstwSFRhRrGtQeUjstxmtPBPWJ0ow+Ew4XCY1tZWIEOUyWSSaDTKwsICY2NjpFKpjAVaOo3Wek1XjELcjA4ZsEGKKyKZTDI4OMji4iJ79+6loaGhKiLaORQ6WDQ3N9PZ2VkVQsx1r46NjdHU1LRi3fAR1+J516QD6DE1txouewwQBY+LwfeUyVkx6HcNksuYYqto9tjCadfgZJVGYI/hcEJ7e9vuRGMoOB94aVesMTAcqHfAF3NxTWEubOGsMWnjF+GYaM4pg594VCucVorpgpDVcIU9bibtaqmM+PmzyszXb71Gbzb6fLqCVGzcp/hRqwWtL31uu2Ka22Y1LZMuxoxgpNOAt1GJ7XHjTl2tEKmC8GnhOEZuI1oY1ZVKlKFQiFAolB+UFxHOnj1LbW3tElcMv9+/JKIMBoNLiDISiWxEijcrcjeC4zhcvnyZmZmZFet45ajArIVCB4uenh6ampp48cUXPXfKgMwN3t/fTygUorOzE8uy8l2oWmsWNLxPQvQ5JqbOdvq7YDlguoIYGVUY1wBtgBhgZf/epDS3uBkyPFFFPYht2uasLr6TtBjcqVzOOgapNVZ8W5mgoSEGNVEHTJfJsI90IPNalQhHXZsx0/KMDFeDVopJgW0IP1EmrqFQImxDs1WEkGTKptdRjChFusz7NaCFO0qIDgvh15oWBc1aCACWeimAzZV202HoDxuc2mEQR5HSAY7MuvRMCeFJTWzWJO1U9l56raNaEzTAY8cNgK3rzCiuR5S5L1idKAG2bNmypGu90D5qcnKSZDKJZVnU1dXx1FNPoZR6WWyj/uAP/oDvfe97aK25++67+eIXv/hTbe7ZIEUyN9jw8DCjo6N0dnauWMfL1eEqbY2GpQ4WXV1dSxwsvLSpgsyNPzg4SCKRYN++fdTX1zM+Pk46ncZ1XSIiPCI+viB+XMlYL5Hxl89cqwWGlbFo0mlW9AYMofD7hAZTmK5GMYsM8QRsm5S/tGaB1dCQVac5UeLCG1cWaIu6GGxNuISUQ8Knea6m9HGJcnCruMwYih8XdJSKUlxFcXXZW2+K0CGaFjLklJJM5DmKWtPI+RbXJbladCjCZoRNCLVkRNlEhPlkkphhEAsGmTMNml2XETHYglCPcEqt8z4b8OQWkye3AAfAEOHwvObANaFxSkhcUyRSpX1WXjfuGFWoZoR8QkMZ01WlEKXjOCwuZoYrXdfNE2UgECAQCLB58+b8MdLpNPPz81y8eJFnnnmG4eFhTp48yZEjR3jd617HL//yLxd9jcXYRj311FP85Cc/yc8ovv71r+dHP/oRb37zm0t/UzzCBimSuRFs2+auu+5alfRyYxmVkKKIMDk5yeXLl2lra8unLwtRrv7pchQSb3d3Ny0tLfm64XSohv9IiIWoS71SnAz4cZXi9drl2RXCMBvFAgrlF/apTCflYNoglnV5iKM4aZv4bOG1PpcxIzMT5yVu12lOekSIt+AyIwZniuxeXQ2TOjOMoVzhtbZLk0+YNIXzPpNFj7s8GkTYi+Z4Cc0SrlIMK8Xwsu8HRNghmk0IPoEEMKkU86K4U2uuiqIRYZu4GGTGVBJKMUc2nasMppefrOYl0Yo7HZdzYpBGEcvOuxwQjauEvvXIMQutFCebFCebgKwf9r6o5vA1oWUa7CnFQmz19zhoaVL22p+BVvD8ETh4FgJFCBuU4PhVNLyUd1uJKCORCBcuXKClpQWfz7duROn3+2lpaeGzn/0sjz76KK7r8sEPfpBTp06t6HCxFoqxjVJKkUwmSafTiAi2befroz8tbJAiEAqF6O7uXvNnvHCwyMnAreVgUel5RISpqSkuXbq0xDoqVzc87sKHalqwwsJm7XI8u/31uy7nUxqs1RctQdGXXRn8fuGAcsGFftvAQWGjeN42UQjHLJeoScbFokLsxuWMUXlruCnCHUpzwjXQHka0gqLfNcHNzDEeMzTNlkPcUly14IL5kjpOOTgmLhcNg+MevJcAKaW4qBQXC77XpjUdWniywjGONzguz8iNzh/nMUDgqLhMK8VwGZumC3UGF+qA3Zl/b18U7rimaZ8Grinm5hWSuz+NFKl1xA5evAUu7oHpLfCWxyG4jvpN0mMBdICtddUZkM9lv6anp28wT1+vRgkZgl1YWGD79u00Njbylre8peRrKMY26jWveQ1vectb2LZtGyLC/fffT29vb8nn8hIbpFgkyiWrRCLBwMAArusWJQNXidHwwsIC/f391NTU5PVXC5to/lEsfl8CHEQziEFfQT7oqIITVvH5oTSK5yXT7dgYyBBk1IZLbmYW8axjggO3mRplCacxkDLqBH4RXJUh3ErQjqYOeNatbs3PRfGiNiENvrRwh2WzORlBI6i6OoYDJsNFRpFbRbNVCc9U2Vduv+tyXRtcrKCOY2jhdVpzfB2NvecxMUV4jbhczEad5WIspBjrNCFryNKcFu6adtl5DZoSPsxZjeuAbUPKVYh+6fVd2wLns5rTC43ww5/LEGNoDU3yuMcC6FAdIfB4PM758+dpbm7m6NGjN5SCimnmmZiY4Fvf+ta6GqSV2kZdvHiRvr4+xsbGgIzc25NPPskb3vCG4l5sFbBBihTvqViK0XChl2JPTw+bNm0q6vdM0ySdLk2kMtctm0wm87vC5fOGD4mfv9M+blWaE8sWLkOEiQqMU+dRPCMZiZh2n6ZDhKu2YlJnulRxocfQNFqa55WBXcLie9jQPFthmvMoLgOuwWSV6p2roVsW+aEZQmqbaEGzG6EjLfQoBz8wb0CfaXJ9mVuvEuGW6AIDtbVc9cCIeS3c6bi8KAbJCgjRr4UjruZ4kR1QLopnMAmK8DpxOaMMoh40Vlz3K/6/NoNjbZpTmCRR3KpdLIGzWREJ04VGR2MHBCloioo0wL+/3WXruEKljWyDWabRrNYVdriC4aGYeg5eRooiwsjICJOTk/T29pbUOVooHPCP//iPPPTQQzz00EO8853vXPP3KrWN+qd/+ifuuuuufLDwjne8g6effnqDFH8W4JWnYqUOFqVEijnJuampqSXdsoXzhmkUH5MgA1pRg9xAiACHRXO2VBXtVTAuGcd7fLBPaVpszQXbYNQ1GHGgGc0mUzNkZBbiXJ0mX6/JaaIB+5XLc2sN6Wc32YYGJVlpNRFqFISycmxaMhZMYYT4y0iKXakFTtfX56Pjaxhck0wK94DSxBSccQ2atbDf1gQN4bpSxEyFYcCZl2E+7I2Oy9NSXgSfQ70WulzhZBktwUkyBtCNIrwWlxMYZXfLAhwQlxiK58TgiGgiWnG+8LoMcAzY7hdOrXC9C0GTUGcaxxHmfIWzNy/dlD0Jze3XhNCkYvq6QldYaFyv87RYxONx+vr6aGho4NixY2UJfszOzvLxj38c0zR5/PHHi97Ir4acbdQDDzywqm1UR0cHDz/8MH/0R3+EiPCjH/2Ij370oxWdt1KoEkVfX7UKsblC72oYHR1FROjo6Fjx/wu1Q7ds2cKuXbvKasq5fv06U1NTa+bVCxt22tvb6ejoyNcNC7vOrqP4TR1EAc/K6nW0A7ZmwMNh+O2JBFsSKebNMNeN0iy0ZNnfBJUnSa3AsbIEqkorfQURDliaCxjMV5kcu9IRBurqcNZZ4FvR7DKEQRTXsmnEIEKP0gQMuGIqRizvR1z8Wjjq6iWaqOWgVWvqXRjyaAxnG5rtSngOY83u2OXYJMJuNH1icKtoRrRicpVrukNsnlmnjbQdDS6rHiOHzSnN62c0m6cU16eNkr0bDSV86X9exFfBxyAijI6OcvXqVXp7e8saoRARvv/97/OZz3yGT37yk9xzzz2ejETMzs5yzz33MDIykreNam5uXmIb5bouv/3bv80TTzyBUoq3v/3t/M3f/E3F514FRb2oDVLMwrbtNb0MJycnSSQSeXfoQuRmAIPBIHv27KnIwSISiTA8PMzBgwdX/P/5+Xn6+/upq6uju7sbv99/AxkqpRjA4I9cP9OiuLTGw71fXC7alUeJO7Wm0xGm04px1/uFXAOOPzMuArDN0IiCqyWSeQ1Cr6U5K0ZVBt73kKQ/GCBdAvGaCAeVxlVwZhkhbEfTZghRE140DZIVaqM2a2G7K3k3kHLRpTVpF6aqMJe6G01YCafXIW0lwp1opkWxTQvnxSC6xvve4aS4alrYRcySbkNjZpWaioHf1tw1naZrxiA5bRFNrv97W2o0f/628o2VE4kEfX191NXVsXv37rJNhB944AHm5ub4+te/npeQe5WiqIdnI31aJHKi4IUorOVV08Eid66BgQHS6XS+YWc1ndIfuQZfFx+nZO2hdIBwBR1127WmyxXm0ooRx2Cu/EOtiUZLY5swV0CAE9rAQrjDcjmvjUzrfxGIozjhmDQq4YDlckpXlrIrRI/pMOArjRAhU2N7QTJ+jtvQdBqai9nocQyDMQ1oCNvCIeWWHUW2JRKgLM77KuvkvdV1GdNrE1AluJTtVL1VXFIK+lcgx92iaRONoxUTohhZh7z8rksaiiJEyJBhq6lpc3VRur1pn8ETbUGeaMuIvd9yLUbvlOC/HmA+sfL73VpbXowhIoyNjTE+Ps6+ffvKkmITEZ544gkeeOABPvrRj/KBD3ygKgYHr0RskGKRKKwpOo5TNQeL5bXLwnPt2bOHLVu2AKyqU/qYa/B32seZImo8HaIzCjElYIur2aeFaFpxxTE4XdJvl44DfptzWKRXqN04BQR31HJ53ik+7TYvmdnKLUrYYbk8r411051rodtyuWSZN0jflYpJDCZ1Jnq8Xbk4Cs5mo8ckijOSGf3AhZ508VHkIddl2Bcqu6GlXgvNWujUmhcwSbwMiiPnssbPx8RlQinGlEGNCK/RLtdFcVyKX74O4HDSV1oqfwqDFlNo15rxEjISYijOba3lXDbo6lhIcWA4QcOsRSxRmy9jlFNPXFxcpK+vj5qaGo4dO1ZWdJhIJPjTP/1TBgcH+ed//mc6OztLPsarGRvp0ywcx1mzwSUWi3Hx4kU2b97M8PAw27dvZ8eOHZ7vrlzX5cSJE9xxxx1MTExw5cqVJedaKVWqlEILfFlbfE37WChyYX6t63Ki2BEFDbfaLjNpg12WxgIu2waRakw0kzFe3UOcc/61R1gKscvU+JRwoYxu1TZDs8UUTunS6lm58477FJEqRU5b0ew0hAFWH2FYqxb5esfluRXk2oJaaBahxrUxF5NYjoMlEBQImBam6cM1fSwogwkx8o1KYYRdhqZGZTpoB5RBqsok2SDCMXEZFoPLJaZsb1cOJyrY/29BU6Nh1IO6e2Nac+d4kuarLgfUKPtrp6mrq6O+vp76+npqampW3GCLCOPj44yNjbF3794V5dKKwTPPPMPHPvYxfv3Xf5377rvvZosON2qKpWA9UpyYmODFF19kx44ddHV1VUWwe0HgK7bJT2auk7R8mD6LzaEQNYYijBBGCEnmz7CCGgVhMl//jzb5Tgk7500ipGzWT/UJ1NlCXYq8gk0OJkK3JdQq4aqTGcHwAnVKaA1qzpc5U3ib5XJVFFNlLGKdhqbWFE4X2Y27w9TM+BRzL0NnqyXCmwyXqCiyGVVcXjJIloLvWWT0aQ0yUmwhcqbKgkg+2ETSadKxBCoUZtoXZAqFW+Jr8SN0KaHeEKJZkvQiklQi3IKmRuC8GCTKeI/b0CwoVXR6fTVsQmjQwrBHDWnvNBy+ZKVRjk00GiUSiRCJREgkEpimuYQoTdOkr6+PUCjEnj17ymrgS6VSfO5zn+OZZ57hkUceoaenx5PX8QrDBimWAtd1Vxy5yDlYGIZBIpHgda97nefnjgl8wzH5um0Qye6CN4mmwyyv1b0YvN511x1kVy40JQWnyBnGDlPTYgjXUjajBKCMhXG7pUlacLVCgg0gHLRczrhmWTN43abGNIQX1yDHNkMT8StmXgZC3CGaepUhB6+wNbWIiMms5UdliW2zEuYVDOjShcBzsBB2KaHJEOIqY3e1UMKx2kWzU4RhUUU3uqx1HQMeNQM1IzRpYajCz+CDhs2fWTarZbtt+yWinJqaIhaLEQqFaG5uXjeiXAlnzpzhd37nd3jve9/Lxz/+cU/0m1+h2CDFUrCcFNPpNBcvXiQajdLT00NjYyNPP/00r33taz0756LAf3ZM/k/b5Poqn9dh5TKEYtZDLdGQCLU2q6dZNQRTQsDmBrmuYrFZaTosISUwkJWBWw/7Ay4DZUYEq6HRSdGCzYUS0rCF6NYpYq7NWGjp77cqTTJQne7LQvhEOKo0z2e1RL1CRzxGzB8iskqHZy3CbkPjB0aojJwUQqcSthhCSsFlw2B22YIeznpQJkTRhyr7vivEXcrlaY83lY0IW7RwuUxi/ISZ5iPW+vPOqVSK8+fPEwgE6OnpQURWjCjr6+vzUeVyorRtm89//vN8//vf5xvf+Aa33nprWdf8KsIGKZYCrTW2bd/gYLF169b8jfbUU095Qoppgf/qGHzJtrhWxOdUn60XVTpXlsNrtbuqO4SVhlBKUB7WCsNK6LY0BnDJNm5Iw4JwKKR5zr1RM9Mr7HSTpEUzVqao+EHLZQ7FEAablUYCMF5lQtyPS7yIzspS0ZtMMGqFSmoK2q4yTT2LAv0VKuDkjrddaRxDUaOEYW0wgfJsTOagcjlLde6nBoRWLVwqgRhNhP/DSvNr5trt3rkZ5KGhIfbs2bPEwWI5CiPKHFFOTU3xL//yL3R1dfHd736XX/zFX+TTn/70qlrLNxk2SLEUuK7L6Ogoly9fZtu2bXR2dt7Q2VUpKToC/801+IJtMV4G6RxULtdQTFQQNZoibHeEiWUPtHIzuo9WFUSPC2GRIcgaBWOOIiKKrqDmhSprkkImYjlsaS5pxVwZRLPF1Oz1axJmZmD9KqqoCLhUNEjGjeS5FYS1K8UxN80Z8ZVcNyyEH2GPoalVMCGq6OH9VidFYzoJIiwEgkz6Ajc0NQURmhDqs6pEfjJZeAFSZBw9FkRxndW9IjchiILZKqa16xG2ac3FImrPAYSvWGnetg4hptNp+vr6sCyLnp6esvoW5ubm+Iu/+AuefvppGhsbmZmZoa6ujnvvvZcPf/jDJR/vVYaNOcVSEIvFmJubW9PBAsozGtYC/901+BvbYqiCCOysmAS1y+2S5JQZQJcxyH1E9NImEg2BFPhtKXBRrB4cFBeyUWq7pdnt0yRfpq2WoHjeMalRmfnG553VxzAanUWalIPfZ5D0+7hqWVzB4EoBAfgQOtBsUhm/QgeICFyl+LnJ5TiKyxAGz3oku1eI14rDs1J5xJDOiZ5n0aqETqVxFFzSmfphMNuhWq8yRDYiBhP+ABP+tccikigmUEwU3hOr3B91WtOsoDZLoD7AVGAp4fEqL20RFGIY9GiXgTU+qwaEv/OluNNYe/xiamqKy5cv50e8ysHw8DD33Xcfhw4d4oknniAUyriEzM/PMzdXrSniVx82IsUsRGRdIe5nn32Ww4cPl7SDmxb4qm0y6EIqHsdNp2isrSUUCGCRSasYIpgIFgpLZYzlc18Wkv+7th3+xTboN4LUO2kcpYgX4WxRyMNbXc1MLkqUTHRoei/Uvy5uC7icFSOfwus1XRyBiy9DxJhDm6FpNoRphKCdwDDAqQkzapgVj1dsQWhRmlwlMi4whWJ6laiqTTSblXimQVsIU4Rj6OLHb8o9D8LhrDKPX8Go8j71uxYOGy7DKvMe70bThPACxdWzy0UNwk6tubDC59aK5lu+FL3G6stmOp3mwoULGIbB3r17y4oOtdb8/d//PQ8//DBf/OIXedOb3lTyMW4SbKRPS0ExpHjq1Cn27t1LOFx8XSqnPjEyMkJHRwfbt2/Pi3avNG9YDP6vtMlfJf1EdeUPe6MSHvCneCZp8XjSXFcBp1KElLA7qHl+lQX6VtNlXitGPRrvWAv1SlNnJUlrh2QoxHg1rNWXoQahHaFeZQTLU5JpanlBzIrHBlZCQIQDojldodPIWqhD2G9oroji2rK0/A6l2WYIM8BgmfZh66EFzVZzZZHvVjRdCGcwqiYIvxIx7laaf/Cl2K5WXzKvXbvGpUuX2L1794oOEsVgYmKC+++/n87OTh566KElvokbuAEbpFgqUqm1XUbPnj1LZ2dn0XJus7OzDAwM0NzczO7du7EsqyIyXI7/kjb5fNJPrCxyFN7sd/laME3O3i+i4V8XLb6zaHLeAz3U5ei0NAkLxtdqKoT/AAAgAElEQVQhPBPhNksz5iimPRxBKMROM8WoBfPZdJ4f4YjSvCAGiy+DWgtkZgYPmZkGKgthG8JmEUJkUu4xDZNiFC3GsBwNImwXob9KG4xtaHYYwjldXMfwFiXsNDQxoI/KFIQgM8e4Nz7Ppdo6kutYbNUhHEBzCcW1KkSvIYRurTkvJoeUy3/xpWheY+TiwoULiAj79u0rqwlGRHjsscf4/Oc/z4MPPsg73vEOz1S1XsXYIMVSsR4p9vX10draSnNz85o/F4/H6e/vRymVjyxFZImJZyVkuBzfTFt8OekjXiQ5KtH879cv878YKRoaGqivr79hdmnAVnx73uX/TfmJmZXXoQ4FXV7QpY0V+LPkeNExmPeoG1YhdOkIZ+rrV1Suack6NVRrPjQHK+vacaKI8zRmCbNeBFMy0eV1yWh+rtYws1U0YZ2p5XmNHuVSo+CMNspu2KnLNus4BvSVsRHpUhplUPIMog/hEJoZ1JL6sBcIItyDw6dNm/AqLyfnpNPV1UVra2tZ55menuZjH/sY4XCYL37xi+uuRxvIY4MUS8V69lGDg4M0NDSsmurIGQvPz8/T09OTv1mX65RWY0cnAg/bFl9P+oisQY5bDM23axbZlFpkYWGBhYUFIpEIWmvq6upoaGggFAoxMTFBOp1m154eTlgNfGfR4qlU6YtgjRI6gprTFdSzahD2m5rzrkGiAnKsE4eQmeBSzfqR/i3KJYpiuApRhU+7bE/FGKwr3eZnyXEQWl2HcCJBvc+H6c+k1A0NtlZMicKBijpNczAQbjM0cVGe2oxBpjtzr6GxVCbFOrfG8xFEuNXUPOdBrfBWXDRZjdUKoBDuVi6/azjcrlYu0Nu2zcDAAI7j0NvbW3Z0+L3vfY/PfvazfPrTn+Y973nPRnRYGjZIsVSsR4pDQ0P4fD7a29uXfF9rzdjYGKOjo3R2dtLe3l5x3bBciMBX0xb/OWUxvyRtJrzD7/LFUHpFoRmtdd626vr16/h8PgKBAPX19TQ0NNDQ0EDEF+K7SYvvJCyGi7CH6vK5zBuKSY8W0UYldBuaM46BXeKC2GZHudYQYq4EJ3uLzOD8GQ9tpkIIOy3N2SpFoq9xXS7YBosF74/KGi77yDVvkW/yMpc1dhn5PwUDsCSj5OKS6X5eTWTCKxgibE/F2Rz0MWb6uFowfnRAuUwbqijXilLQYSdpUnDODJSk4mMi/Afl8ruGTe8atcOZmRkGBwfZuXPnkrnnUjA/P88f/uEfEo/H+epXv1p2lHmTY4MUS8V6nopjY2O4rrtEVX5mZoaBgQE2b95MV1eX53XDciECX0lbfCPlQwT+UyjFf/Cv/tpmZ2cZHBykpaUlP6Np23Z+MHhhYYHFxUWCwSD19fWM1LXwA6uJ/5H2rRC9CYeCOuM8UYVFtEVlalkvOKsbJ790KUIXEc7WrZwuLQabyYwcFJPqXAu1CNssoa8aNS0Rjjiakx51mPokU2Mdc1/SkPUh3GJqUsCLUp2mmeXYpTTbTI1pwJOYVRUe35RO0ZpMcLmmnuQa7hN+hPcql/sNm11rkKHjOHm7t97eXgKB0lw6IBMdPv744/zxH/8xv//7v8+99957s4l4e4kNUiwVxRgNx+Nxdu/enddENU2TvXv3EgqFqlo3LBeSbdioW+UZTyQSDAwMYBgGe/bsyc82rXwsIZVKLUm7xlzhXNN2flyzjfNGmAalaQ0K516G0YodhqZJCWdXUeepc1PU18IFq/TFaCX0Kk0SSnZpgMy8WrMlDFbDlFdrTNub+qElwu3LyHAltCtNmylc0AbzVbvHhdstTR8GERS+rFxcsxIc4CqKcQ/lD3OoE02PneKyYTJnvZTmDGrNLzsJfscv7LDWvr9zTXadnZ1s27atrHUgFovxqU99iqGhIR555BF27NhR8jE2sAQbpFgq1nPKmJ2dZXJyEsMwWFhYWGLh8nLUDb2E67pcuXKF2dlZ9uzZU3axXkSIxWJEIhEuRJOc0D6GgvVMhOoZ9YWIeyRNtxa6DY0foa+AiDslwdX6INc9JiEzm1I9LwaRIj/jTQhhSzxv7AC4dWGBK77aos1zV0OODMfd0tLd/mz0GAf6PEwJ7zQy0WH/Ou9ZE0KH0oQURMhsWLxKdfuzTTkx4E1OkvfMTWEuzOdr8LW1tXmB7rq6OkzTxHGcvPF4b28vwWCwrHM/9dRTfOITn+DDH/4wv/Vbv7URHXqDDVIsFWuRotaagYEBxsfH6e3tze/+fhZSpaVARJiamsr7NLa3t1fFEzKXcr0SSzLoKibDDVyraWTMX8Ow8i+peXmFXXYcWwtNDX6OW76q6ahCZjHuzkmxrfF5t6JRFox5TIi1Ihx0NKcqjMjLJcOV0KE0rYaUtGFYjjDCfivTSFNOg5CB0KGELVmptykUw6iiU71+hF40h1Xm65DS7EFuqMNrrYnH4/mMSTQaxXEcbNtm8+bN7Nixg7q6upKfrWQyyZ//+Z/z/PPP88gjj9Dd3V3S7xeL0dFR3v/+9zM1NYVSig9/+MN85CMf4fr167zvfe9jaGiInTt38thjj5Xt3fgziA1SLBWrkeL09DSDg4M0NjaSTCY5cuTIK44MAaLRKAMDA4RCIbq7u19WkeBUKpUnyoVIhDGtmK3bxLW6Jq4Gahk2glwpYWSjSQlbDE2NEux0mphtkwyGmTEsthnCZlOYMmGgypFqj9JohMEVoqQ2NGkLJj0mxL3axbFVSW7wy2Fp4YjhctU1PGuEyiGAcMDURIALJUSPt5kuo8r7OcK6bE24RkEcGCaT8lUIXQiH1EskeAuaQImPseu6DA4OEo/H2bFjR/5ej8ViKKVuMBFejShPnTrFRz7yEX7lV36F3/u937tBe9lLTExMMDExwZEjR4hGo9x+++185zvf4dFHH6W5uZkHHniABx98MK+l+irBBimWiuX2UdFolP7+fvx+Pz09PRiGwenTp/Ok+EpJleZGRWKxGD09PUWLD1QTIkIikcgTZSQSwRUh2rCZmfpNTIbrGTYCjGsjI32nwFYQEcWULt40tkVpdlgZ89vzysCuwmdlZFOqF+Ql38BOpVkwvfdafL3jcrrI7ltThC3ZGlyYTFTouC7BtM28A7gOl0N1pKu4+HYami2G8KI2iK3y3rcqzWZTOF3l2dAc2tH8sWXzZsOlocKPZ35+ngsXLuSzLsvXAtd1lzhZxGKxvImwbds4jsO+ffv4/Oc/zw9/+EMefvhhbrnllsouqgz80i/9Evfffz/3338///7v/862bduYmJjgzW9+M/39/S/79VQJG6RYKnKkWOiluHfvXhobG/P//+STT9Ld3U1jY+OaTSk/C8hJzI2NjVXUDv5yQWtNNBp9qYknu4DEm7dwrr6F5/z1nBRf2VJ0tVmHDteEPmUQ9fi9aEDYqzSzwKRlMO8hITaIsM9eKtcWzpJeA0IwO1phC8RRzAvMLBvu34uLqRWDBeM0NQjdpJkRYcQqr/5VDPzaZR82MZ8vH1VbWdeSFzCqkk5fjjqE+0yb3zAdghWeznVdLl26RDQaZf/+/SWtBY7jEIlEOH78OF/+8pfp7+8nGAzy7ne/mzvuuIPXve51L2tTzdDQEG984xs5d+4cHR0dzM/PA5n1o6mpKf/vVwE2XDJKhYgwNDTE+Pg4XV1d9Pb23lA3vOWWW5ibm2NycpJkMkk4HM6rwjQ0NFQ15VEK5ubmGBwcpKmpiWPHjr0i3LYNw8jPROaQGwvpWJjkdQv9zMTinA81MtjawZnazUyo4l9XDMULjglOZkG+3XQJmHDJUEyV08UooASUFnYYQqtPiAHTGPh1JiLJzQdm5gIz583PAqrMU6pESCWTOLZDuCaMaZr53acG/K4QcjPuFIdxiYpiVhQLKEZFMbrOZW5Ds10k89qXIY7iNAFQ0C0ZgfTza0R15SJtmJzBBBf2GJqthiZuwgkxqxK9F8JC+F8Nh49ZNps8ONXCwgJ9fX20tbWxZ8+ekjealmXR0NCQT7l+73vfY9euXZw8eZLnnnsOEeFXf/VXK7/QIhCLxXjPe97DF77whRsySK+ELFg1sBEpFuD69etMTk6yc+fOzMK0Tt1QRFhcXKoMIyJ5ZZiGhoYb3LCrjWQyyeDgII7jlCxe/rOMXCq7traW9vZ2EokECwsLnE/YPB9u5Fx9C32B+rL1NHcbmiZLuGooLq1EkFkCNHTmK6gF0eTnJEXAkMwDYvsh7YdKNbi7tGaTI5wt80C1IhxUmjN2afJ6QYReK9tR6rFrx37TxTYUfdk6poXQroTNKiMkEJfMqMWMR6MW/5Ph8EnTZvcaThXFQmvNpUuXWFhYYP/+/WU/W5cvX+a+++7jzjvv5M/+7M/K7lCtFLZt8853vpO3ve1tfOxjHwNg7969G+nTDVJ8CVprbNteMmtYat0wV0PIEWU8Hsfv9+dJsqGhoSoNLq7rMjIywtTUFN3d3Ws6dr+S4DgOly5dIhKJsG/fvhVdAHKdgBMLEZ5MK44bYU7XbGLOV9584lY0myxhhoy+KFphaqGoZ0rAZ4PPAccE25chyFJIslU03Y5wyi1CnGAFWJKpcV7yQDN2u6HZagj9Ulk6+BbTJWko+ots6mlEaDMy1luugjkyc5jFDu/fplz+xLJ5zTo+hsUiEonQ19fH1q1b6ejoKGujq7Xmm9/8Jo8++ihf+tKXeMMb3uDJtZUDEeEDH/gAzc3NfOELX8h//xOf+ASbNm3KN9pcv36dv/zLv/ypXafH2CDFUpEbTvd63nD5wLtt29TU1ORJspzW7cJrnpmZ4dKlS/kH9tUw0yQiTE5OMjQ0REdHB21tbSV9Fo7jcCKyyOMpeEqFGAjUoleJAHOwEMIK/EC9ErYamp2GJmDAC9pkSBssuCDrEU02YvSnwVfQzOwaLxGk7QPXZMlj2iDCrW5Gxq7cuukhXBZcxZjHzhhWtqM0peC8NopWB9qVjJDy+xjxV15/NxHaslGlX2XMiydFMVnwuW5H84eWzbsMd0U5w1Khteby5cvMzc2xf/9+ampqyjrO+Pg49913H93d3Tz00ENlH8cr/PjHP+YNb3gDBw8ezK8Xn/vc57jzzju55557GBkZobOzk8cee+zVJDi+QYql4tvf/jbf+c53OHr0KHfccQcHDx6sSlQnIsTjcebn5/MzTkqpJdFkMBhclwRybhx+v589e/aUJSP1s4icWlA4HKa7u7ss49XliGh4fFHzg6Qw57gEk4sE7TR1lkGXT3F72MfBujDWOkolAJdd+B+uxXOuwaBrMO0q0hrU8mcuS46BNFgrjL/mSFJ8Qq+pGdJlzPfpzMzktmz9su9lUBJqVZoOU7gkq5kmCwctTUQpLlXJ+qsQdQg9hv7/2zvzoKjO7O9/b3ezL80iIAIqKjZNcJSlMVqj0Ti4ZMxY0UwSE7MZx6RGSyqJ0dexNDqWxhi3wYkao86iyc8sk0RfnfE3ZTLMqGERIiovm+wiLTvdQO/3Pu8feO90IyDddNNN+3yq8keohD59gf4+5zznfA9+JTFhuZi1eqSiPzo7O1FSUiJYH9qaHZ45cwaZmZnYu3cv0tPTH8l7OheBiqK1GI1G3LhxAzk5OcjNzUVRURH8/PyQmpoKhUKBtLQ0qzOWwcJ3pPEZJe8zGhQUJDTx8M0yJpMJVVVVwjYOvjt2pMOyrHAql8lkFg03joAfC+EzePM7Yf6Z+/v7D+rn3cUBP7AiXGXFKGJFaGBF6GYBgAG5fx/pZQDEA1TzOAYwSXoySFYEiDkCn/tLiL3Q4z0qIgw4Ahg5QEMYC9/ZGElP2becEaF1GLo5xSCYYNLCxBpR7RMIlgF+JuHQwTCoGgYxBHqG7V+WmLDOw4ggO71ljuNQU1ODlpYWJCQkwN/f36bv09TUhIyMDAQFBeHgwYPuNAQ/UqGiOFQIIWhra0Nubi6ys7ORm5sLpVKJSZMmQaFQQKFQICkpCT4+PnYXSkIIdDqdRdmVZVmIxWJotVpERUUhNjbWbUqlzc3NqKysRHR0NKKjo512mmZZFl1dXRZ3whKJRBDJwMDAQWXxQE/zzQ/tnfi/HVrUBYXhnsQHGhPA6RiICAMxQyAWAb4igmAxQbiYIEpMECvhIBMTdLHAOa0E/9GJrXJ3EYMg3rNn9KSIOGY2szdpHiYQhoGBAVrAoJYwVm2csBYGBE+LWbznYcRYOzTR8HR1daG4uBhhYWEYN26cTX9fhBCcO3cOu3btwo4dO7BkyRKaHboGVBQdAcuyKCsrQ3Z2NvLy8vDTTz8BAJKTk4Wy68SJE+0uViqVSphnCggIQFdXl/CBbV52HWklVI1GY1ECHk6XncFiNBotDic6nQ4+Pj4WQtm7xGswGFBeXg6WZSGTySw6DBtNgJ8I8B/kr4jSxOArjQTfaCRoH+QiaZ4gEUGsB4d7IsYmI/OHESdmQcQMSnvdYfqAYKyIQMoQGAHcA4O7ZPB2awORZOjGe4wGj/t7220EiuM41NbWorm5GXK5vM+GrsHQ3t6O9evXw2Qy4fDhwwgLC7NLfBS7QEVxOOANsfPz84VssqqqClFRUUI2mZqaCqlUatNp0WAwCAbDMpnsgVKOwWAQPrBVKhUMBsMDTTyuMjtpDsuyQonK3CBhJNBfFs8bRBsMBjQ1NWHSpEn9LqS2BQMB/qkV40y3BLeM1v9Mx0k4BHsQFEME1RDLq1H3R1gKrRgXCQBBjIiDPwPoGKCBMGi0QqjjGBYZJjWSVM3CXTwAi3L3QDZq/dHV1YWSkhKEhITYXH0hhODSpUvYsmULNm7ciBdffJFmh64HFUVnwXEc6urqkJ2djZycHFy7dg1arRZTpkwRhDIhIWHAgXqO43Dnzh00NDRgwoQJCA8PH2TJrqeJx9w+jWEYi6zG19fXqX+wfKk0MjISMTExblEC5jgOzc3NqKioAMMwEIlEEIlEDnvuxQYG/9Ptgf/Viq3uVPUAgcyTg/F+edWa2c5gcIj1JHbblRnCEEQzHLzv+5LWkQdXUUUwHN72MOI5MQtxr5c0t1Hjy91isVjwGpVKpf1ebxBCUFtbi8bGRsjlcpvtDzs7O7F582Y0NDTg008/fWAJOcVloKLoSuj1ely/fh05OTnIyclBSUkJgoKCBJFUKBSIiIgAwzC4fPkyPDw8EBYWJhgJDAXzrRUqlQoajQZeXl4WZVd7dHg+DK1Wa7G70VlDy/aGz3pbW1stGoTMm6fUarXw3PkPa3vMrHZwwHcaCb7sluAua/3hIkREMN6TQz3DoHaArM2bcHjMk+Amcbwl22iGw2iGwF9EoBBzWOVhgo8VL2m+HLv3c+efvclkQnFxMYKDgzFhwgSbs8MrV65gw4YNWLNmDVatWuUWBzw3hoqiK0MIQVNTE3JycoT7yYaGBhBCEBQUhO3btyMtLc1hwmFe/lOpVEL5j/+w9vf3t9sfOH9f09jYiMmTJ7vT3BPa2tpQXl4+6KxXp9NZCKW9yt0cAS7rRfii2wM/6kU2rc2aIOEQ4EHw/yBC5/3/X0w4TPVgUQEJ2oahoxUAAkHwuqcRr3uaEGinl+RnhdVqNRobG6HT6SCVShEaGiqIpTUHQ61Wi+3bt6OoqAgnTpxAbGysfQLtg5UrV+L8+fMIDw9HUVERAKCwsBBvvfUWdDodJBIJDh8+jLS0NIfF4CZQURwpGI1G7NixA//4xz/w5ptvgmVZ5OTk4ObNm/Dw8EBKSoqQTdraEfcwOI6z6Lrkzbh7z05aS2trK27fvo2IiAiHxe4M+EYa3k7PVnP43uXuzs7OIVsF1poYfNktwVmNBJ02ONp4gkOsvh2SAB90eXmhaJi2V0hBsNLTiFftKIbmaDQaFBcXQyqVIjY2VriP5zNKlmWFA4r54uDe5Ofn4+2338aKFSuwbt06h9/Z/+c//4G/vz9eeeUVQRTnz5+Pt99+G4sWLcLf//537NmzB1lZWQ6Nww2ghuAjBYlEgilTpmDr1q3CPeObb74JQghUKhWuXbuG7OxsfPXVV6itrcX48eOFucnk5ORBz9INBH//FRgYKDj0m3dd3r17F3q9XjBA5z84+vtA0Ol0KC8vByEEU6dOdfmNIoOFEAKlUona2lqr7nr7g2EY+Pv7w9/fH2PGjAFgaRVYXV1t0WXMl/8GOqCMkxC8JzVibYARf9eK8UW3B8pMDx5GGBBEiAlCJQQeIsDAcWg0GNEi8cYtz9Ce/0gPjGIIIkU95UwiAlQA7hD7mYYHgeANTyNe8TQhwAFiyG+LuXv3LuLj44WmLolEAl9fX0RGRgL4r12gWq1GQ0OD0MgjkUjw73//GwqFApcuXUJ2djZOnz4NuVxu/2D7YPbs2aipqbH4GsMwUKvVAHo60/nfHcrQoZniCIM3JeabeH766ScYjUZMnTpVyCZlMplDTq997UDksxreZMDHxwf19fXCPKe7eLACPQ5CpaWl8PPzw6RJk4Z184jBYLC4F9br9fDx8bE4oAwUz3W9CN9oxFBCBA2ADsJAyTHQDaEkGn5/V6K3qGfXZQsY1BNm0HORwQzBGx49YujvoMqsVqtFcXEx/P39MWnSJKv/LliWhVKpxKFDh3D58mU0NTUhNjYWCoUCs2bNwrJlyxwTeC9qamqwePFiIVMsKSnBggULBJ/mH3/8EePGjRuWWEYwtHz6qKDRaFBQUCA48ZSXlyM8PFyYm0xNTUVoaKhDOk7Ns5rm5maoVCp4eXkhIiICQUFBDjNAH044jkN1dfUDjTTOxHxDi3n5r7cbT+9ytYYAP+jFuKCX4KpxcMuKrUECgjEighBxz9YLDdMzo3jPrIknxEwM/RwkhoQQ3L17F/X19ZDJZDa7yZhMJmRmZuLcuXP45JNPkJSUBJVKhYKCAjQ0NGDFihV2jrxveoviunXr8MQTT2DZsmX48ssvcezYMVy6dGlYYhnBUFF8VCGEoKGhQcgmc3NzoVarkZCQIJRdExMT7SZW/P2a0WgUslTzJh6j0WjRxDMUA/Thpr29HWVlZSPCbN38Xpif4+tvPIHjOBTV3sFFLYNbEbH4iXjatJFjsPgxBAkSDr/wNuFZTxa+DuzZ0el0KC4uhq+vL+Li4myumty+fRtr167Fz3/+c2zbts2pxhi9RVEqlaKjo0PY9yqVSoVyKqVfqChS/ovRaMTNmzcFg4GioiL4+voK2aQtvq78XU19fT0mTpyIsLCwfufBzJt4Ojs7LRYKD9YAfTgxGo0oLy+HwWBAfHz8iL0TNRqNFqvMtFotxGIxdDodgoODhdGYJg64qJfggl6Mm30sIx4KY0QcVvqY8Ky3yW5m3X1hft8rk8ls7nJmWRbHjx/HqVOn8Mc//hEzZ860c6TW01sU5XI5jhw5gjlz5uD777/Hhg0bUFBQ4OQoXR4qipT+GaqvK287x895WXsaN5lMQkbT0dEhWKcN9o7MUZivrLJHI40rwRuut7W1YfTo0UL3JZ/J89lkh28g/tfkiQt6CW7bMPvIEyvm8BsfIxZ7sfBw8CPU6XQoKSmBt7c34uLibP7duXPnDn77298iISEBH374oUss6V6+fDmysrLQ0tKCiIgIbN++HTKZDBkZGTCZTPD29sbhw4eRkpLi7FBdHSqKFOvgOE7wdc3Nze3T19Xf3x8HDhzAr3/96yHtl+tNf9Zp5qMJ9uiyHQiNRoPS0lL4+PjYbWWVq8CXgceMGYOYmBiL58iPhZhn8gAQGBiItqAwXPUOxSXigzuD3NEoF3NY7WvEfE8WIgeLofkhZvLkyQgNDbXp+3Ach9OnT+PIkSPYt28f5s2b5zaHIYoAFUXK0DD3db169Sr+9re/oba21qLkOhRf14fBcZxF6c9RBuj8qqDm5uYR58P6MEwmEyoqKqDRaCCXywddBjZvoOKffZ1/KAqCo/CjVzBamQczsSQJi9W+RszxtM+2+4eh1+tRUlICDw8PTJ482eZDzL1797Bu3TqEh4fjwIEDLtFIRXEIVBQp9sFgMGDBggVISkrC1q1b0dHR0aevKy+WD/N1HWos9jRAb29vF7p13clcAABaWlpw+/ZtjB071i57QPln36FWI0cHXPEOQUFABOI4Hd7w0GKO1GvYSt737t1DdXU14uLibB77IYTgm2++wZ49e7Br1y4sXryYZofuDRVFiv1QKpXCkHNv9Ho9CgsLBaEcyNfV3vRV+jM3QO/PENpoNArbR+Lj413i7shemK+tio+Pd1jXJCEE3RotOtX/LXlzHCeUvAMDA+1qFwj0vLfS0lKIRCLIZDKbs8PW1la8++67EIvFOHTokFvN01L6hYoixTmY+7ryIyEtLS2YPHmyMBIydepUh/m68kbc/LC7RqOBt7e3IJR6vR51dXWIjY11mFg7A/65V1VVYcKECYiIiBj2GPiSN//sebtA80OKrZ3GjY2NqKqqwsSJE21eyUUIwcWLF7Ft2zZs3rwZzz//vNv8/CkPhYoixXXgtxLw2aS5rytfdnVU+ZIQAr1ej+bmZtTU1IDjOHh6ej7QxDOSS6d6vR6lpaUQi8VDyqAcgfnWCn4sxPyQ8rAtLQaDAWVlZQAAmUxm83ytWq3Gpk2b0NLSgmPHjvVb+aC4LVQUXYk7d+7glVdeQWNjIxiGwerVq5GRkeHssJxGb1/X3Nxch/m68ls6mpqaMHnyZAQHBzvMAH244Y0a6urqhnS/NpzwhxTzTmOTydSnGTe/o3IomS8hBJcvX8bGjRuRkZGB1157bUQfgCg2Q0XRlVAqlVAqlUhOTkZnZydSUlLw3XffISEhwdmhuQy8rytfdi0oKIDBYMC0adNs9nXt6OhAWVmZsJtyoA9DcwN03l90sAbozoAfIfH19R12L1Z7w3c6m/vq8muRxo4di9DQUJuWNGs0Grz//vsoKyvDiRMnHO4P2teaJwA4dOgQPv74Y4jFYvzyl7/Enj17HBoHpU+oKLoyS5Yswdq1a5Genu7sUFya/nxdU1JSkDZGms0AAA2GSURBVJaWBoVC0aevq9FoREVFBbRarc2NNLwBurm/aG8DdGvXOtkDQgjq6uqgVCottj64C3zX7Lhx4+Dt7S08++7ubnh6elpsCxmoiSgvLw/vvPMOXn/9daxZs2ZYssO+1jz961//ws6dO3HhwgV4eXmhqanJ5jtRypCgouiq1NTUYPbs2SgqKkJgYKCzwxlRPMzXNTU1FYWFhaioqEBGRgZGjx5tV9Hqa36P/6Dm/3GkAXpXVxdKSkoQHByM2NhYl8pchwpvrWc0GiGXy/sUPL1eb5FNmmfzWq0WkZGR8PHxwa5du5Cbm4tPP/0UMplsWN9Hb0u25557DqtXr8YvfvGLYY2D8gBUFF2Rrq4uPPHEE9i8eTOWLl3q7HDcAt7X9cKFCzh27BgCAwMxatQoJCUl2ezrag3m92OOMkDnDQZaWlogl8sREBBgp+hdg9bWVpSXl2P8+PFWHWTM15l9/vnn+Pzzz9HW1oaxY8fijTfewMyZMx06N9sXvUVx2rRpWLJkCS5evAhvb2/s3bsXCoVi2OKhCNAlw66G0WjEsmXL8NJLL1FBtCMeHh4ghODs2bP47LPPMHv2bAtf17/+9a9oaGjApEmTkJqaCoVCgeTk5H59Xa3Fy8sL4eHhQkmMX1arUqlQX19vsa3ClrEElUqF0tJSYR2YOzWJmEwmYV40KSnJ6uYmhmHg5+cHT09PcBwHqVSKU6dOgeM45Obm4qOPPsKiRYvw4osvOugdPByTyYS2tjbB7OK5555DVVUVHQVxUWimOEwQQvDqq68iJCQEBw8edHY4bofJZALLsv3eMT3M11WhUGDSpEkOExx+LIHPJgdjgM6yLCorK6FWqyGXy+3mM+sqtLW1oby8HDExMUPK5MvKyrB27VrMnTsXW7dudfr+zt6Z4sKFC7Fx40bMnTsXADBx4kTk5OQgLCzMmWE+itDyqStx5coVzJo1C1OmTBE+eHft2oWnnnrKyZE9mvBOOPn5+YJQVlRUICoqSmjgcaSvK2+A3tHRIYiluRsMwzCoq6tDdHQ0oqOj3SqrYFkWt2/fhkajQUJCgs2jLyzL4ujRozhz5gyOHDmCtLQ0O0dqG71F8ejRo2hoaMDvf/97lJeXY968eairq3Orn+kIgYoihWINHMehrq5OaOLJz8+HRqMZNl9XjuPQ3t6OyspKYRyhdxOPMxfd2gN+W0d0dDSioqJsFoba2lqsWbMGU6dOxa5du1xm32Vfa55efvllrFy5EoWFhfD09MTevXvx5JNPOjvURxEqihTrYVkWqampiIqKwvnz550djtMZTl9XflDdvNnE3gbozoJlWVRUVKCrqwsJCQk2ixjHcfjLX/6CY8eO4eDBg0JJkkIZBFQUKdazf/9+5OfnQ61WU1HsA95f1Hw5M79yylZfV97GjBCC+Pj4Ae/EbDVAdyYdHR0oLS1FVFTUkErBSqUSa9euRUxMDPbt2+d2HbgUh0NFkWId9fX1ePXVV7F582bs37+fiuIgMfd1zc3NxY0bN+Dh4YHk5GRBKPvydTVfkDsUk2veAJ2f3TM3QOdNBpzhhcqyLKqqqqBSqZCQkGDzJhJCCL766ivs378fu3fvxqJFi1xK9CkjBiqKFOt49tlnsWnTJnR2dmLv3r1UFG3kYb6uCoUCISEh2LNnDzZs2AC5XG5X0ertLapSqcCyrMXspKMN0PkxksjISMTExNgsYs3NzXjnnXfg4+ODzMxMhISE2DlSyiMEnVOkDB7erzElJQVZWVnODmdEwzAMgoKCkJ6eLtj4cRyHqqoqXL16FR9++CFu3bqFxx57DMeOHbPZ13Wg1/f29oa3t7dgom1ugF5XV+cwA3T+fba3tyMxMdHmMRJCCC5cuIAdO3bg/fffx7Jly2h2SBkWaKZIAQBs2rQJp06dgkQigU6ng1qtxtKlS3H69Glnh+Y2EELwzDPPYOLEidixYwcAoKCgALm5ucjNzRWMy/lO1/58Xe2FvQ3Q1Wo1SkpKEBERgXHjxtkcd0dHBzZu3IjOzk588sknTtkLSXFLaPmUYhtZWVm0fOog2tra+i0B9vZ1zcvLE+7j+GxyypQpDhtONzdA5+8nAVg08fS1qYLjOFRXV6OtrQ1yuRz+/v42v35WVhY2bdqEd999Fy+//LJbufdQnA4VRYptUFF0HYxGI27duiUI5a1bt+Dn5ydkk472dWVZ1sKJR6PRwMvLSxBKsViMiooKhIWFDWlJdHd3N7Zs2YLq6mocP34cMTExdn4n/6W/9U4AsG/fPqxfvx7Nzc0jYjclxSqoKFIo7gYhBG1tbcjLyxOaeBoaGjBx4kQhm7Snr2tf8E48d+7cQWdnp4VI2mKAnp2djfXr1+M3v/kN3nrrLYdnh32tdwJ6FoGvWrUKpaWlKCgooKLoflBRpLgfHR0dWLVqFYqKisAwDE6ePIkZM2Y4Oyyn0tvX9fr16yCEOMzXlV9fFRISgtjYWAB4YHZSJBI90MTTW6R1Oh127tyJ/Px8HD9+HHFxcXaJbzD0tmIDerqvt2zZgiVLliA/P5+KovtBu08p7kdGRgYWLlyIr7/+GgaDARqNxtkhOR2RSAS5XA65XI6VK1c+4Ou6bds2VFZWYsyYMUPydSWEoLa2Fo2NjUhISLAYng8ICEBAQACio6MBWBqgK5VKwQD9+vXrGDVqFIKCgvC73/0OL7zwAn744Qenu/KcPXsWUVFRmDp1qlPjoDgfmilSRgwqlQrTpk2ja3dsgPd1zcnJEVYYaTQaJCYmCgYDA/m6dnd3o7i4GMHBwZgwYYLVWSchBFqtFt9++y3OnDmDW7duISwsDDNnzsT06dPx1FNPYcyYMfZ4q4PCPFPUaDSYO3cu/vnPf0IqlWL8+PE0U3RPaKZIcS+qq6sRFhaG119/HTdu3EBKSgr+8Ic/uN1KJUcgEokwfvx4jB8/Hi+88AIAS1/XgwcPorS0FFKpVMgk09LSMGrUKBw8eBAKhQLTpk2DVCq16fUZhkFNTQ1OnDiBhQsX4uLFi+A4DoWFhcjNzUVjY+OwiqI5lZWVqK6uFrLE+vp6JCcnIy8vD6NHj3ZKTBTnQTNFyoghPz8fjz/+OK5evYrp06cjIyMDgYGBwswfZWj09nXNyspCRUUFEhISsGDBAsyYMcNqX1egp4P1448/xtdff42jR48iNTXVQe9g8PR1p8hDM0W3ZVCZIh0CoowY+N2C06dPB9DTGMEvC6YMHYZhEBERgV/96leIi4uDwWDAt99+i0OHDmHUqFE4deoU0tPT8eSTT2L9+vX44osvUF1dDY7j+v2e1dXVWLx4MVpbW3HlyhWXEMTly5djxowZwgqrEydOODskigtBM0XKiGLWrFk4fvw4ZDIZtm3bhu7ubnz00UfODsvtuHbtGhITEx9Y8UQIgVqtFkZC8vLyUFtbi3Hjxgkl15SUFPj5+eHkyZM4efIkMjMzMXv2bCe9EwpFgI5kUNyPwsJCrFq1CgaDARMmTMCf/vQnBAcHOzusRxre75Q3GCgoKEBlZSWefvppZGZm2uxwQ6HYGSqKFArFObS0tCAkJITatFFcCXqnSKE4gwMHDuCxxx5DYmIili9fDp1O5+yQhp1Ro0ZRQaSMSOhvLYViR+7evYvMzEzk5+ejqKgILMvizJkzzg6LQqEMEiqKFIqdMZlM0Gq1MJlM0Gg0Tpu/o1Ao1kNFkUKxI1FRUVi/fj3Gjh2LyMhISKVSzJ8/39lhUSiUQUJFkUKxI+3t7Th79iyqq6vR0NCA7u5uuqiZQhlBUFGkUOzIpUuXEBsbi7CwMHh4eGDp0qX48ccfnR3WiGPlypUIDw9HYmKi8LX33nsP8fHx+NnPfoZnnnkGHR0dToyQ4q5QUaRQ7MjYsWORk5MDjUYDQgi+//57yOVyZ4c14njttddw8eJFi6+lp6ejqKgIN2/exOTJk/HBBx84KTqKO0NFkUKxI9OnT8ezzz6L5ORkTJkyBRzHYfXq1c4Oa8Qxe/ZshISEWHxt/vz5whaPxx9/HPX19c4IjeLm0OF9CoXikgxk2v3000/j+eefx4oVK5wQGWWEQof3KRSK+7Fz505IJBK89NJLzg6F4oZQUaRQHiH6amBpa2tDeno64uLikJ6ejvb2didGODB//vOfcf78eXz22Wd00TTFIVBRpFAeIfpqYNm9ezfmzZuH27dvY968edi9e7eTohuYixcvYs+ePTh37hx8fX2dHQ7FTaF3ihTKI0bvuzqZTIasrCxERkZCqVRizpw5KCsrc2qMy5cvR1ZWFlpaWhAREYHt27fjgw8+gF6vR2hoKICeZpujR486NU7KiIJuyaBQKA/SWxSDgoKEmT9CCIKDg+kMIMUdoY02FArFOhiGoXd1lEcaKooUyiNOREQElEolAECpVCI8PNzJEVEozsPa8imFQhnhMAwzHsB5Qkji/X//CEArIWQ3wzD/B0AIIWSDE0OkUJwGFUUK5RGCYZj/ATAHwCgAjQDeB/AdgC8BjAVQC+A5Qkibs2KkUJwJFUUKhUKhUO5D7xQpFAqFQrkPFUUKhUKhUO5DRZFCoVAolPtQUaRQKBQK5T5UFCkUCoVCuQ8VRQqFQqFQ7kNFkUKhUCiU+1BRpFAoFArlPv8fORGfvpd3kt8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_value(V) # 绘制状态价值图"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 蒙特卡洛控制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random    # 随机策略时用到\n",
    "\n",
    "def greedy_pi(A, s, Q, a):\n",
    "    '''依据贪婪选择，计算在行为空间A中，状态s下，a行为被贪婪选中的几率\n",
    "    考虑多个行为的价值相同的情况\n",
    "    '''\n",
    "    #print(\"in greedy_pi: s={},a={}\".format(s,a))\n",
    "    max_q, a_max_q = -float('inf'), []\n",
    "    for a_opt in A:# 统计后续状态的最大价值以及到达到达该状态的行为（可能不止一个）\n",
    "        q = get_dict(Q, s, a_opt)\n",
    "        #print(\"get q from dict Q:{}\".format(q))\n",
    "        if q > max_q:\n",
    "            max_q = q\n",
    "            a_max_q = [a_opt]\n",
    "        elif q == max_q:\n",
    "            #print(\"in greedy_pi: {} == {}\".format(q,max_q))\n",
    "            a_max_q.append(a_opt)\n",
    "    n = len(a_max_q)\n",
    "    if n == 0: return 0.0\n",
    "    return 1.0/n if a in a_max_q else 0.0\n",
    "\n",
    "def greedy_policy(A, s, Q):\n",
    "    \"\"\"在给定一个状态下，从行为空间A中选择一个行为a，使得Q(s,a) = max(Q(s,))\n",
    "    考虑到多个行为价值相同的情况\n",
    "    \"\"\"\n",
    "    max_q, a_max_q = -float('inf'), []\n",
    "    for a_opt in A:\n",
    "        q = get_dict(Q, s, a_opt)\n",
    "        if q > max_q:\n",
    "            max_q = q\n",
    "            a_max_q = [a_opt]\n",
    "        elif q == max_q:\n",
    "            a_max_q.append(a_opt)\n",
    "    return random.choice(a_max_q)\n",
    "        \n",
    "def epsilon_greedy_pi(A, s, Q, a, epsilon = 0.1):\n",
    "    m = len(A)\n",
    "    greedy_p = greedy_pi(A, s, Q, a)\n",
    "    #print(\"greedy prob:{}\".format(greedy_p))\n",
    "    if greedy_p == 0:\n",
    "        return epsilon / m\n",
    "    n = int(1.0/greedy_p)\n",
    "    return (1 - epsilon) * greedy_p + epsilon/m\n",
    "\n",
    "\n",
    "def epsilon_greedy_policy(A, s, Q, epsilon, show_random_num = False):\n",
    "    pis = []\n",
    "    m = len(A)\n",
    "    for i in range(m):\n",
    "        pis.append(epsilon_greedy_pi(A, s, Q, A[i], epsilon))\n",
    "    rand_value = random.random() # 产生一个0,1的随机数\n",
    "    #if show_random_num:\n",
    "    #    print(\"产生的随机数概率为:{:.2f}\".format(rand_value))\n",
    "    #print(rand_value)\n",
    "    for i in range(m):\n",
    "        if show_random_num:\n",
    "            print(\"随机数:{:.2f}, 拟减去概率{}\".format(rand_value, pis[i]))\n",
    "        rand_value -= pis[i]\n",
    "        if rand_value < 0:\n",
    "            return A[i]\n",
    "\n",
    "def epsilon_greedy_black_jack_policy(A, s, Q, epsilon, show_random_num = False):\n",
    "    _, player_points, _ = s\n",
    "    if player_points >= 21:\n",
    "        return A[1]\n",
    "    if player_points < 12:\n",
    "        return A[0]\n",
    "    else:\n",
    "        return epsilon_greedy_policy(A, s, Q, epsilon, show_random_num)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 测试上面三个函数\n",
    "test_S = [str(i) for i in range(10)] # 10个状态\n",
    "test_A = [str(i) for i in range(3)] # 3个行为\n",
    "test_Q = {}\n",
    "for s in test_S:\n",
    "    for a in test_A:\n",
    "        set_dict(test_Q, random.random(), s, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Q_of_s(A, s, Q):\n",
    "    qs = []\n",
    "    for i in range(len(A)):\n",
    "        qs.append(get_dict(Q, s, A[i]))\n",
    "    return qs\n",
    "\n",
    "       \n",
    "def verify_greedy_policy(A, S, Q):\n",
    "    for s in S:\n",
    "        qs = Q_of_s(A, s, Q)\n",
    "        print(\"Q({},)={}\".format(s,qs))\n",
    "        a = greedy_policy(A, s, Q)\n",
    "        qsa = get_dict(Q, s, a)\n",
    "        max_qs = max(qs)\n",
    "        print(\"q({},{}) = {},{}\".format(s, a, qsa, max_qs))\n",
    "        if qsa == max(qs):\n",
    "            print(\"verified\")\n",
    "        else:\n",
    "            print(\"wrong\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_Q['3_0'], test_Q['3_1'], test_Q['3_2'] = 0.2,0.4,0.5\n",
    "s,a = '3','1'\n",
    "epsilon_greedy_policy(test_A, s, test_Q, epsilon=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_policy(policy, A, Q, epsilon, useable_ace = 0):\n",
    "    def value_of(a):\n",
    "        if a == A[0]:\n",
    "            return 0\n",
    "        else:\n",
    "            return 1\n",
    "    rows, cols = 11, 10\n",
    "    Z = np.zeros((rows, cols))\n",
    "    dealer_first_card = np.arange(1, 12) # 庄家第一张牌\n",
    "    player_points = np.arange(12,22)\n",
    "    for i in range(rows): # 庄家第一张牌 1,12\n",
    "        for j in range(cols): # 玩家总牌分 12,22\n",
    "            s = j + 1, i + 11, useable_ace\n",
    "            a = policy(A, s, Q, epsilon)\n",
    "            Z[i,j] = value_of(a)\n",
    "    \n",
    "    plt.imshow(Z, cmap=plt.cm.cool, interpolation=None, origin=\"lower\", extent=[1, 11, 11, 22])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "display = False\n",
    "# 创建一个玩家一个庄家，玩家使用原始策略，庄家使用其固定的策略\n",
    "player = Player(policy = naive_policy, role=\"玩家\", display = display)\n",
    "dealer = Player(policy = policy_for_dealer, role = \"庄家\", display = display)\n",
    "# 创建一个场景\n",
    "arena = Arena(display=display)\n",
    "player.policy = epsilon_greedy_black_jack_policy\n",
    "#player.reset_memory()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000000/1000000 [02:05<00:00, 7944.22it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共玩了1000000局，玩家赢341701局，和57293局，输601006局，胜率：0.34\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "arena.display = False\n",
    "player.display = False\n",
    "dealer.display = False\n",
    "player.policy = epsilon_greedy_black_jack_policy\n",
    "arena.play_games(dealer=dealer, player=player, num = 1000000, show_statistic = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOsAAAD8CAYAAACW2VP2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvFvnyVgAACxJJREFUeJzt3X+s3fVdx/Hny138AcwxQsUKRRazQXBxIFeDI8q2qmmUWOIfRpKRLiM2LssEQsSNJS7+ocGNoDMmmmZUSGzqJnRuMUZpGBlZMjBt7fhVIn+4YUdZS4iOuOhs9vaP+y25Xu7lnF7Ouee+e5+PpLnnfr/fe77v5vbZzznnntxvqgpJ69/3zXoASeMxVqkJY5WaMFapCWOVmjBWqYmRsSbZkuSRJM8keTrJLcP2TyV5NskTST6f5LzpjyttXBn1c9Ykm4HNVXUoyZuBg8ANwMXAl6rqZJI/Bqiq35v2wNJGNXJlrapjVXVouP0KcAS4qKoeqqqTw2GPsRCvpCmZO52Dk1wKXAU8vmTXB4HPrvA1O4GdAOdwztWXc/lpDymdyQ5y8KWq2jTquJEPg189MDkX+DLwh1W1b9H2jwPzwK/XiDubz3wd4MBY55M2ipCDVTU/6rixVtYkZwEPAnuWhPoB4Hpg66hQJb0xI2NNEuBe4EhV3bNo+zbgDuC6qvrO9EaUBOOtrNcCNwFPJjk8bLsT+DPgB4D9Cz3zWFX99lSmlDQ61qr6CpBldv3D5MeRtBLfwSQ1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1MTLWJFuSPJLkmSRPJ7ll2H5+kv1Jnhs+vnX640ob1zgr60ng9qq6ArgG+HCSK4CPAg9X1duBh4fPJU3JyFir6lhVHRpuvwIcAS4CtgP3D4fdD9wwrSElneZz1iSXAlcBjwMXVtWxYdeLwIUrfM3OJAeSHDjBiTcwqrSxjR1rknOBB4Fbq+rbi/dVVQG13NdV1a6qmq+q+U1sekPDShvZWLEmOYuFUPdU1b5h87eSbB72bwaOT2dESTDeq8EB7gWOVNU9i3Z9Edgx3N4BfGHy40k6ZW6MY64FbgKeTHJ42HYncBfwuSQ3A98AfmM6I0qCMWKtqq8AWWH31smOI2klvoNJasJYpSaMVWrCWKUmjFVqwlilJoxVasJYpSaMVWrCWKUmjFVqwlilJoxVasJYpSaMVWrCWKUmjFVqwlilJoxVasJYpSaMVWrCWKUmjFVqwlilJoxVasJYpSaMVWrCWKUmjFVqwlilJsa5mPLuJMeTPLVo25VJHktyOMmBJD873TEljbOy3gdsW7Ltk8AfVNWVwO8Pn0uaopGxVtWjwMtLNwM/PNx+C/DChOeStMTIK5+v4Fbgn5LczULw717pwCQ7gZ0Al3DJKk8nabUvMH0IuK2qtgC3AfeudGBV7aqq+aqa38SmVZ5O0mpj3QHsG27/LeALTNKUrTbWF4DrhtvvA56bzDiSVjLyOWuSvcB7gAuSHAU+AfwW8Okkc8B/MzwnlTQ9I2OtqhtX2HX1hGeR9Dp8B5PUhLFKTRir1ISxSk0Yq9SEsUpNGKvUhLFKTRir1ISxSk0Yq9SEsUpNGKvUhLFKTaxprAevhtTk/kgbiSur1ISxSk0Yq9SEsUpNGKvUhLFKTRir1ISxSk0Yq9SEsUpNGKvUhLFKTRir1ISxSk0Yq9SEsUpNjIw1ye4kx5M8tWT7R5I8m+TpJJ+c3oiSYLyV9T5g2+INSd4LbAfeVVU/Cdw9+dEkLTYy1qp6FHh5yeYPAXdV1f8MxxyfwmySFlntc9Z3AD+f5PEkX07yMysdmGRnkgNJDnDixCpPJ2m1sc4B5wPXAL8LfC5JljuwqnZV1XxVzbNp0ypPJ2m1sR4F9tWCfwa+B1wwubEkLbXaWP8OeC9AkncA3w+8NKmhJL3W3KgDkuwF3gNckOQo8AlgN7B7+HHOd4EdVeVv8pWmaGSsVXXjCrveP+FZJL0O38EkNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSEyNjTbI7yfHhWqxL992epJJ41XNpysZZWe8Dti3dmGQL8MvA8xOeSdIyRsZaVY8CLy+z60+AOwCveC6tgVU9Z02yHfhmVX1tjGN3JjmQ5AAnTqzmdJKAudP9giRnA3ey8BB4pKraBewCyPy8q/AZKuv4O1uZ7P1N/O865nyrWVl/Angb8LUkXwcuBg4l+dFV3JekMZ32ylpVTwI/curzIdj5qnppgnNJWmKcH93sBb4KXJbkaJKbpz+WpKVGrqxVdeOI/ZdObBpJK/IdTFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFIT41xMeXeS40meWrTtU0meTfJEks8nOW+6Y0oaZ2W9D9i2ZNt+4J1V9VPAvwIfm/BckpYYGWtVPQq8vGTbQ1V1cvj0MeDiKcwmaZG5CdzHB4HPrrQzyU5gJwCXXDKB0y2675ro3ekMdab8O3lDLzAl+ThwEtiz0jFVtauq5qtqnk2b3sjppA1t1Strkg8A1wNbq+oM+b9LWr9WFWuSbcAdwHVV9Z3JjiRpOeP86GYv8FXgsiRHk9wM/DnwZmB/ksNJ/nLKc0ob3siVtapuXGbzvVOYRdLr8B1MUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjVhrFITxio1YaxSE8YqNWGsUhPGKjWRtfwlD0lOAN+Y4F1eALw0wfubpPU8G6zv+dbzbDD5+X68qkb+zqM1jXXSkhyoqvlZz7Gc9TwbrO/51vNsMLv5fBgsNWGsUhPdY9016wFex3qeDdb3fOt5NpjRfK2fs0obSfeVVdowjFVqol2sSbYkeSTJM0meTnLLrGdaTpI3JfmXJH8/61kWS3JekgeGS3YeSfJzs55psSS3Dd/Xp5LsTfKDM55nuUuenp9kf5Lnho9vXYtZ2sXKwrV1bq+qK4BrgA8nuWLGMy3nFuDIrIdYxqeBf6yqy4F3sY5mTHIR8DvAfFW9E3gT8JuznWrZS55+FHi4qt4OPDx8PnXtYq2qY1V1aLj9Cgv/2C6a7VT/X5KLgV8FPjPrWRZL8hbgFxh+SXtVfbeq/mO2U73GHPBDSeaAs4EXZjnMcpc8BbYD9w+37wduWItZ2sW6WJJLgauAx2c7yWv8KQvXAvrerAdZ4m3ACeCvhofon0lyzqyHOqWqvgncDTwPHAP+s6oemu1Uy7qwqo4Nt18ELlyLk7aNNcm5wIPArVX17VnPc0qS64HjVXVw1rMsYw74aeAvquoq4L9Yo4dw4xie+21n4T+VHwPOSfL+2U71+oYrKK7Jzz9bxprkLBZC3VNV+2Y9zxLXAr+W5OvA3wDvS/LXsx3pVUeBo1V16pHIAyzEu178IvBvVXWiqv4X2Ae8e8YzLedbSTYDDB+Pr8VJ28WaJCw85zpSVffMep6lqupjVXVxVV3KwosjX6qqdbE6VNWLwL8nuWzYtBV4ZoYjLfU8cE2Ss4fv81bW0Qtgi3wR2DHc3gF8YS1O2i5WFlaum1hYsQ4Pf35l1kM18hFgT5IngCuBP5rxPK8aVvwHgEPAkyz8+5zpWw9XuOTpXcAvJXmOhUcDd63JLL7dUOqh48oqbUjGKjVhrFITxio1YaxSE8YqNWGsUhP/BweBozLUOw4zAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "draw_value(player.Q, useable_ace = 1, is_q_dict=True, A = player.A)\n",
    "draw_policy(player.policy, A, player.Q, epsilon = 1e-10, useable_ace = 1)\n",
    "draw_value(player.Q, useable_ace = 0, is_q_dict=True, A = player.A)\n",
    "draw_policy(player.policy, A, player.Q, epsilon = 1e-10, useable_ace = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10000/10000 [00:01<00:00, 8045.35it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共玩了10000局，玩家赢3440局，和590局，输5970局，胜率：0.34\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "arena.display = False\n",
    "player.display = False\n",
    "dealer.display = False\n",
    "player.policy = epsilon_greedy_black_jack_policy #naive_policy # \n",
    "arena.play_games(dealer,player,num=10000, show_statistic = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [00:00<00:00, 7096.76it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共玩了1000局，玩家赢347局，和57局，输596局，胜率：0.35\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "display = False\n",
    "arena.display = display\n",
    "player.display = display\n",
    "dealer.display = display\n",
    "player.policy = epsilon_greedy_black_jack_policy\n",
    "arena.play_games(dealer,player,num=1000, show_statistic = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1011000"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "player.total_learning_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['继续叫牌', '停止叫牌']\n",
      "-0.24074074074074056\n",
      "-0.5176470588235298\n",
      "-0.6469173965309978\n",
      "-0.5699084668192236\n",
      "3115\n",
      "3115\n",
      "随机数:0.80, 拟减去概率5e-11\n",
      "随机数:0.80, 拟减去概率0.99999999995\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'停止叫牌'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 9, 12, 1\n",
    "print(player.A)\n",
    "\n",
    "print(player.Q[str_key(s,player.A[0])])\n",
    "print(player.Q[str_key(s,player.A[1])])\n",
    "s = 10, 15, 0\n",
    "print(player.Q[str_key(s,player.A[0])])\n",
    "print(player.Q[str_key(s,player.A[1])])\n",
    "\n",
    "print(player.Nsa[str_key(\"6_18_0\", player.A[0])])\n",
    "print(player.Nsa[str_key(\"6_18_0\", player.A[0])])\n",
    "epsilon_greedy_black_jack_policy(player.A, s, player.Q, 1e-10, show_random_num = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
